@eagleoutice/flowr 1.3.11

package/util/objects.d.ts

@@ -0,0 +1,17 @@
+import { DeepPartial, DeepRequired } from 'ts-essentials';
+/**
+ * checks if `item` is an object (it may be an array, ...)
+ */
+export declare function isObjectOrArray(item: unknown): boolean;
+export type MergeableRecord = Record<string, unknown>;
+export type MergeableArray = unknown[];
+export type Mergeable = MergeableRecord | MergeableArray;
+/**
+ * Given two objects deeply merges them, if an object is an array it will merge the array values!
+ * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
+ */
+export declare function deepMergeObject<T extends Mergeable>(base: Required<T>, addon?: T): Required<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<T>, addon?: T): DeepRequired<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: T, addon?: DeepPartial<T> | Partial<T>): T;
+export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
+export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;

package/util/objects.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMergeObject = exports.isObjectOrArray = void 0;
+const json_1 = require("./json");
+/**
+ * checks if `item` is an object (it may be an array, ...)
+ */
+function isObjectOrArray(item) {
+    return typeof item === 'object';
+}
+exports.isObjectOrArray = isObjectOrArray;
+function deepMergeObject(base, addon) {
+    if (!base) {
+        return addon;
+    }
+    else if (!addon) {
+        return base;
+    }
+    else if (typeof base !== 'object' || typeof addon !== 'object') {
+        // this case should be guarded by type guards, but in case we do not know
+        throw new Error('illegal types for deepMergeObject!');
+    }
+    assertSameType(base, addon);
+    const result = { ...base };
+    const baseIsArray = Array.isArray(base);
+    const addonIsArray = Array.isArray(addon);
+    if (!baseIsArray && !addonIsArray) {
+        deepMergeObjectWithResult(addon, base, result);
+    }
+    else if (baseIsArray && addonIsArray) {
+        return [...base, ...addon];
+    }
+    else {
+        throw new Error('cannot merge object with array!');
+    }
+    return result;
+}
+exports.deepMergeObject = deepMergeObject;
+function deepMergeObjectWithResult(addon, base, result) {
+    for (const key of Object.keys(addon)) {
+        if (typeof addon[key] === 'object') {
+            if (key in base) {
+                result[key] = deepMergeObject(base[key], addon[key]);
+            }
+            else {
+                result[key] = addon[key];
+            }
+        }
+        else {
+            assertSameType(result[key], addon[key]);
+            result[key] = addon[key];
+        }
+    }
+}
+function assertSameType(base, addon) {
+    if (base !== undefined && addon !== undefined && typeof base !== typeof addon) {
+        throw new Error(`cannot merge different types! ${typeof base} (${JSON.stringify(base, json_1.jsonReplacer)}) !== ${typeof addon} (${JSON.stringify(addon, json_1.jsonReplacer)})`);
+    }
+}
+//# sourceMappingURL=objects.js.map

package/util/os.d.ts

@@ -0,0 +1,2 @@
+export type Os = 'mac-os' | 'linux' | 'windows' | 'unknown';
+export declare function getPlatform(): Os;

package/util/os.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatform = void 0;
+let platformCache = null;
+function getPlatform() {
+    if (platformCache !== null) {
+        return platformCache;
+    }
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        platformCache = 'mac-os';
+    }
+    else if (platform === 'linux') {
+        platformCache = 'linux';
+    }
+    else if (platform === 'win32') {
+        platformCache = 'windows';
+    }
+    else {
+        platformCache = 'unknown';
+    }
+    return platformCache;
+}
+exports.getPlatform = getPlatform;
+//# sourceMappingURL=os.js.map

package/util/parallel.d.ts

@@ -0,0 +1,30 @@
+export type Arguments = string[];
+type WorkingQueue = Arguments[];
+/**
+ * This is not really generic but written especially for the benchmarking script.
+ * It offers a work stealing thread pool executor.
+ */
+export declare class LimitedThreadPool {
+    private readonly workingQueue;
+    private readonly limit;
+    private readonly parallel;
+    private readonly module;
+    private counter;
+    private skipped;
+    private currentlyRunning;
+    private reportingInterval;
+    /**
+   * Create a new parallel helper that runs the given `module` once for each list of {@link Arguments} in the `queue`.
+   * The `limit` stops the execution if `<limit>` number of runs exited successfully.
+   * The `parallel` parameter limits the number of parallel executions.
+   */
+    constructor(module: string, queue: WorkingQueue, limit: number, parallel: number);
+    run(): Promise<void>;
+    getStats(): {
+        counter: number;
+        skipped: Arguments[];
+    };
+    private runNext;
+    private onChildExit;
+}
+export {};

package/util/parallel.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitedThreadPool = void 0;
+/**
+ * Tasked with parallelize the benchmarking by calling the given script in an executor-pool style fashion.
+ * Now used to parallelize more in _flowR_.
+ * @module parallel
+ */
+const cp = __importStar(require("child_process"));
+const log_1 = require("./log");
+const assert_1 = require("./assert");
+const json_1 = require("./json");
+/**
+ * This is not really generic but written especially for the benchmarking script.
+ * It offers a work stealing thread pool executor.
+ */
+class LimitedThreadPool {
+    workingQueue;
+    limit;
+    parallel;
+    module;
+    counter = 0;
+    skipped = [];
+    currentlyRunning = new Set();
+    reportingInterval = undefined;
+    /**
+   * Create a new parallel helper that runs the given `module` once for each list of {@link Arguments} in the `queue`.
+   * The `limit` stops the execution if `<limit>` number of runs exited successfully.
+   * The `parallel` parameter limits the number of parallel executions.
+   */
+    constructor(module, queue, limit, parallel) {
+        this.workingQueue = queue;
+        this.limit = limit;
+        this.module = module;
+        this.parallel = parallel;
+    }
+    async run() {
+        this.reportingInterval = setInterval(() => {
+            console.log(`Waiting for: ${JSON.stringify(this.currentlyRunning, json_1.jsonReplacer)}`);
+        }, 20000);
+        const promises = [];
+        // initial run, runNext will schedule itself recursively we use the limit too if there are more cores than limit :D
+        while (this.currentlyRunning.size < Math.min(this.parallel, this.limit) && this.workingQueue.length > 0) {
+            promises.push(this.runNext());
+        }
+        await Promise.all(promises);
+        clearInterval(this.reportingInterval);
+    }
+    getStats() {
+        return { counter: this.counter, skipped: this.skipped };
+    }
+    async runNext() {
+        if (this.counter + this.currentlyRunning.size >= this.limit || this.workingQueue.length <= 0) {
+            console.log(`Skip running next as counter: ${this.counter} and currently running: ${this.currentlyRunning.size} beat ${this.limit} or ${this.workingQueue.length}`);
+            return;
+        }
+        const args = this.workingQueue.pop();
+        (0, assert_1.guard)(args !== undefined, () => `arguments should not be undefined in ${JSON.stringify(this.workingQueue)}`);
+        this.currentlyRunning.add(args);
+        console.log(`[${this.counter}/${this.limit}] Running next, currently running: ${this.currentlyRunning.size}, queue: ${this.workingQueue.length} [args: ${args.join(' ')}]`);
+        const child = cp.fork(this.module, args);
+        child.on('exit', this.onChildExit(args));
+        // schedule re-schedule
+        await new Promise(resolve => child.on('exit', resolve)).then(() => this.runNext());
+    }
+    onChildExit(args) {
+        return (code, signal) => {
+            if (code === 0) {
+                this.counter++;
+            }
+            else {
+                log_1.log.error(`Benchmark for ${JSON.stringify(args)} exited with code ${JSON.stringify(code)} (signal: ${JSON.stringify(signal)})`);
+                this.skipped.push(args);
+            }
+            this.currentlyRunning.delete(args);
+        };
+    }
+}
+exports.LimitedThreadPool = LimitedThreadPool;
+//# sourceMappingURL=parallel.js.map

package/util/quads.d.ts

@@ -0,0 +1,92 @@
+/**
+ * As other project partners want the produced data structures as rdf quads, this module provides
+ * serialization capabilities for this purpose.
+ * <p>
+ * At the time of writing this module I am unaware of any sophisticated rdf library for typescript which allows to serialize objects
+ * directly as rdf quads. Therefore, this module provides a simple serialization mechanism based on the popular n3.js library.
+ *
+ * @module
+ */
+import { MergeableRecord } from './objects';
+import { NodeId } from '../r-bridge';
+type RecordForQuad = Record<string, unknown>;
+type DataForQuad = Record<string, unknown> | ArrayLike<unknown>;
+type ContextForQuad = string;
+/**
+ * Predicate that allows you to ignore given elements based on their key/value
+ *
+ * @returns true if the given key/value should be ignored, false otherwise
+ */
+export type QuadIgnoreIf = (key: string, value: unknown) => boolean;
+/**
+ * Deterministically retrieve a unique id for a given object.
+ * @param obj - the object to retrieve the id for
+ * @param context - In order to provide unique ids even for different contexts, we add the context to the id.
+ */
+export type QuadIdRetriever = (obj: unknown, context: ContextForQuad) => string;
+/**
+ * Either a constant string or a supplier depending on the object in question
+ */
+export type QuadContextRetriever = ContextForQuad | ((obj: DataForQuad) => ContextForQuad);
+/**
+ * A deterministic counting id generator for quads.
+ */
+export declare function defaultQuadIdGenerator(): QuadIdRetriever;
+export declare function defaultQuadIgnoreIf(): QuadIgnoreIf;
+/**
+ * See {@link DefaultQuadSerializationConfiguration} for defaults.
+ */
+export interface QuadSerializationConfiguration extends MergeableRecord {
+    /**
+   * Ignore certain keys or values when serializing to quads.
+   * @see defaultQuadIgnoreIf
+   */
+    ignore?: QuadIgnoreIf;
+    /**
+   * Retrieve a unique id for a given object.
+   * @see defaultQuadIdGenerator
+   */
+    getId?: QuadIdRetriever;
+    /**
+   * The context of the serialized quads, probably the file-name (constant) or whatever is desired.
+   */
+    context: QuadContextRetriever;
+    /**
+   * The basic domain name to use for the quads.
+   */
+    domain?: string;
+}
+export declare const DefaultQuadSerializationConfiguration: Required<QuadSerializationConfiguration>;
+/**
+ * Serializes the given object or array to rdf quads.
+ *
+ * @param obj    - The object to serialize (must be a Record and no array etc.)
+ * @param config - Further configuration options
+ *
+ * @returns the serialized quads
+ *
+ * @see graph2quads
+ */
+export declare function serialize2quads(obj: RecordForQuad, config: QuadSerializationConfiguration): string;
+export type VertexInformationForQuad<AdditionalInformation extends MergeableRecord> = MergeableRecord & AdditionalInformation & {
+    id: NodeId;
+};
+export type EdgeInformationForQuad<AdditionalInformation extends MergeableRecord> = MergeableRecord & AdditionalInformation & {
+    from: NodeId;
+    type: NodeId | NodeId[];
+    to: NodeId;
+};
+export interface GraphInformationForQuad<AdditionalVertexInformation extends MergeableRecord, AdditionalEdgeInformation extends MergeableRecord> extends MergeableRecord {
+    rootIds: NodeId[];
+    vertices: VertexInformationForQuad<AdditionalVertexInformation>[];
+    edges: EdgeInformationForQuad<AdditionalEdgeInformation>[];
+    additional?: DataForQuad;
+}
+/**
+ * Serializes the given directed graph to rdf quads.
+ * This is a mere (type-)convenience wrapper for {@link serialize2quads}.
+ *
+ * @see serialize2quads
+ */
+export declare function graph2quads<AdditionalVertexInformation extends MergeableRecord, AdditionalEdgeInformation extends MergeableRecord>(graph: GraphInformationForQuad<AdditionalVertexInformation, AdditionalEdgeInformation>, config: QuadSerializationConfiguration): string;
+export {};

package/util/quads.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * As other project partners want the produced data structures as rdf quads, this module provides
+ * serialization capabilities for this purpose.
+ * <p>
+ * At the time of writing this module I am unaware of any sophisticated rdf library for typescript which allows to serialize objects
+ * directly as rdf quads. Therefore, this module provides a simple serialization mechanism based on the popular n3.js library.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graph2quads = exports.serialize2quads = exports.DefaultQuadSerializationConfiguration = exports.defaultQuadIgnoreIf = exports.defaultQuadIdGenerator = void 0;
+const n3_1 = require("n3");
+var namedNode = n3_1.DataFactory.namedNode;
+var quad = n3_1.DataFactory.quad;
+const objects_1 = require("./objects");
+const assert_1 = require("./assert");
+const defaultmap_1 = require("./defaultmap");
+var literal = n3_1.DataFactory.literal;
+const log_1 = require("./log");
+const domain = 'https://uni-ulm.de/r-ast/';
+/**
+ * A deterministic counting id generator for quads.
+ */
+function defaultQuadIdGenerator() {
+    let counter = 0;
+    const idMap = new defaultmap_1.DefaultMap(() => counter++);
+    return (elem, context) => `${context}/${idMap.get(elem)}`;
+}
+exports.defaultQuadIdGenerator = defaultQuadIdGenerator;
+const ignoredKeysArray = ['complexNumber', 'markedAsInt', 'info'];
+function defaultQuadIgnoreIf() {
+    return (key, value) => value === undefined || ignoredKeysArray.includes(key);
+}
+exports.defaultQuadIgnoreIf = defaultQuadIgnoreIf;
+exports.DefaultQuadSerializationConfiguration = {
+    ignore: defaultQuadIgnoreIf(),
+    context: 'unknown-context',
+    getId: defaultQuadIdGenerator(),
+    domain: 'https://uni-ulm.de/r-ast/'
+};
+function retrieveContext(context, obj) {
+    return typeof context === 'string' ? context : context(obj);
+}
+const writer = new n3_1.Writer({ format: 'N-Quads' });
+/**
+ * Serializes the given object or array to rdf quads.
+ *
+ * @param obj    - The object to serialize (must be a Record and no array etc.)
+ * @param config - Further configuration options
+ *
+ * @returns the serialized quads
+ *
+ * @see graph2quads
+ */
+function serialize2quads(obj, config) {
+    const useConfig = (0, objects_1.deepMergeObject)(exports.DefaultQuadSerializationConfiguration, config);
+    (0, assert_1.guard)((0, objects_1.isObjectOrArray)(obj), 'cannot serialize non-object to rdf!');
+    (0, assert_1.guard)(!Array.isArray(obj), 'cannot serialize arrays (must wrap in object)!');
+    store = new Set();
+    const quads = [];
+    serializeObject(obj, quads, useConfig);
+    return writer.quadsToString(quads);
+}
+exports.serialize2quads = serialize2quads;
+/**
+ * Serializes the given directed graph to rdf quads.
+ * This is a mere (type-)convenience wrapper for {@link serialize2quads}.
+ *
+ * @see serialize2quads
+ */
+function graph2quads(graph, config) {
+    return serialize2quads(graph, config);
+}
+exports.graph2quads = graph2quads;
+function processArrayEntries(key, values, obj, quads, config) {
+    for (const [index, element] of values.entries()) {
+        if (element !== null && element !== undefined && (0, objects_1.isObjectOrArray)(element)) {
+            const context = retrieveContext(config.context, obj);
+            quads.push(quad(namedNode(domain + config.getId(obj, context)), namedNode(domain + key), namedNode(domain + config.getId(element, context)), namedNode(context)));
+            // we now add a next link to the next vertex
+            const next = values[index + 1];
+            if (next !== undefined) {
+                const nextId = config.getId(next, context);
+                quads.push(quad(namedNode(domain + config.getId(element, context)), namedNode(domain + 'next'), namedNode(domain + nextId), namedNode(context)));
+            }
+            serializeObject(element, quads, config);
+        }
+        else {
+            // for the time being, the index does not seem of interest for the graph summary team.
+            processLiteralEntry(element, key, obj, quads, config, undefined);
+        }
+    }
+}
+function processObjectEntries(key, value, obj, quads, config) {
+    const context = retrieveContext(config.context, obj);
+    quads.push(quad(namedNode(domain + config.getId(obj, context)), namedNode(domain + key), namedNode(domain + config.getId(value, context)), namedNode(context)));
+    serializeObject(value, quads, config);
+}
+function objToType(value) {
+    let suffix;
+    switch (typeof value) {
+        case 'string':
+            suffix = 'string';
+            break;
+        case 'number':
+            suffix = Number.isInteger(value) ? 'integer' : 'decimal';
+            break;
+        case 'boolean':
+            suffix = 'boolean';
+            break;
+        case 'bigint':
+            suffix = 'integer';
+            break;
+        default:
+            log_1.log.warn(`unknown ${typeof value} with ${JSON.stringify(value)}`);
+            break;
+    }
+    return suffix ? namedNode(`http://www.w3.org/2001/XMLSchema#${suffix}`) : undefined;
+}
+function processLiteralEntry(value, key, obj, quads, config, index) {
+    const context = retrieveContext(config.context, obj);
+    // we have to create an object if there is an index, so that we can link the index!
+    if (index !== undefined) {
+        const newId = `${key}-${index}`;
+        quads.push(quad(namedNode(domain + config.getId(obj, context)), namedNode(domain + key), namedNode(domain + config.getId(newId, context)), namedNode(context)));
+        quads.push(quad(namedNode(domain + config.getId(newId, context)), namedNode(domain + 'value'), literal(String(value), objToType(value)), namedNode(context)));
+        quads.push(quad(namedNode(domain + newId), namedNode(domain + 'order'), literal(String(index), namedNode('http://www.w3.org/2001/XMLSchema#integer')), namedNode(context)));
+    }
+    else {
+        quads.push(quad(namedNode(domain + config.getId(obj, context)), namedNode(domain + key), literal(String(value), objToType(value)), namedNode(context)));
+    }
+}
+function processObjectEntry(key, value, obj, quads, config) {
+    if (config.ignore(key, value)) {
+        return;
+    }
+    if (guardCycle(value)) {
+        return;
+    }
+    if ((0, objects_1.isObjectOrArray)(value)) {
+        if (Array.isArray(value)) {
+            processArrayEntries(key, value, obj, quads, config);
+        }
+        else {
+            processObjectEntries(key, value, obj, quads, config);
+        }
+    }
+    else {
+        processLiteralEntry(value, key, obj, quads, config, undefined);
+    }
+}
+let store = new Set();
+function guardCycle(obj) {
+    // @ts-expect-error we do not care about the type here
+    if ((0, objects_1.isObjectOrArray)(obj) && 'id' in obj) {
+        if (store.has(obj.id)) {
+            return true;
+        }
+        store.add(obj.id);
+    }
+    return false;
+}
+function serializeObject(obj, quads, config) {
+    if (obj === null || obj === undefined) {
+        return;
+    }
+    if (guardCycle(obj)) {
+        return;
+    }
+    if (obj instanceof Map) {
+        for (const [key, value] of obj.entries()) {
+            processObjectEntry('key-' + String(key), value, obj, quads, config);
+        }
+    }
+    else if (obj instanceof Set) {
+        let i = 0;
+        for (const value of obj.values()) {
+            console.log('set', value);
+            processObjectEntry('idx-' + String(i++), value, obj, quads, config);
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(obj)) {
+            processObjectEntry(key, value, obj, quads, config);
+        }
+    }
+}
+//# sourceMappingURL=quads.js.map

package/util/random.d.ts

@@ -0,0 +1,4 @@
+export declare const ALPHABET_LOWERCASE: readonly string[];
+export declare const ALPHABET_UPPERCASE: readonly string[];
+export declare const ALPHABET: readonly string[];
+export declare function randomString(length: number, symbols?: readonly string[]): string;

package/util/random.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = exports.ALPHABET = exports.ALPHABET_UPPERCASE = exports.ALPHABET_LOWERCASE = void 0;
+const assert_1 = require("./assert");
+exports.ALPHABET_LOWERCASE = [...'abcdefghijklmnopqrstuvwxyz'];
+exports.ALPHABET_UPPERCASE = [...'ABCDEFGHIJKLMNOPQRSTUVWXYZ'];
+exports.ALPHABET = [...exports.ALPHABET_LOWERCASE, ...exports.ALPHABET_UPPERCASE];
+// we could do this with type guards etc. but this way it is easier to read I guess
+function isPositiveFiniteInteger(length) {
+    return isFinite(length) && length >= 0 && length === Math.floor(length);
+}
+function randomString(length, symbols = exports.ALPHABET) {
+    (0, assert_1.guard)(isPositiveFiniteInteger(length), `length must be a positive, finite integer (${length} >= 0)`);
+    (0, assert_1.guard)(symbols.length > 0, 'there must be at least one symbol to use');
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += symbols[Math.floor(Math.random() * symbols.length)];
+    }
+    return result;
+}
+exports.randomString = randomString;
+//# sourceMappingURL=random.js.map

package/util/range.d.ts

@@ -0,0 +1,32 @@
+export interface SourcePosition {
+    /** starts with 1 */
+    line: number;
+    /** starts with 1 */
+    column: number;
+}
+export interface SourceRange {
+    /** inclusive start position */
+    readonly start: SourcePosition;
+    /** inclusive end position */
+    readonly end: SourcePosition;
+}
+/**
+ * at the moment this does not ensure ordering of start and end!
+ */
+export declare function rangeFrom(line1: number | string, col1: number | string, line2: number | string, col2: number | string): SourceRange;
+export declare function mergeRanges(...rs: SourceRange[]): SourceRange;
+/**
+ * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
+ */
+export declare function rangeStartsCompletelyBefore(r1: SourceRange, r2: SourceRange): boolean;
+/**
+ * Checks if the two ranges overlap.
+ */
+export declare function rangesOverlap(r1: SourceRange, r2: SourceRange): boolean;
+export declare function addRanges(r1: SourceRange, r2: SourceRange): SourceRange;
+/**
+ * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.
+ *
+ * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
+ */
+export declare function rangeCompare(r1: SourceRange, r2: SourceRange): number;

package/util/range.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeCompare = exports.addRanges = exports.rangesOverlap = exports.rangeStartsCompletelyBefore = exports.mergeRanges = exports.rangeFrom = void 0;
+const assert_1 = require("./assert");
+/**
+ * at the moment this does not ensure ordering of start and end!
+ */
+function rangeFrom(line1, col1, line2, col2) {
+    return {
+        start: {
+            line: Number(line1),
+            column: Number(col1)
+        },
+        end: {
+            line: Number(line2),
+            column: Number(col2)
+        }
+    };
+}
+exports.rangeFrom = rangeFrom;
+function mergeRanges(...rs) {
+    (0, assert_1.guard)(rs.length > 0, 'Cannot merge no ranges');
+    return {
+        start: rs.reduce((acc, r) => acc.line < r.start.line || (acc.line === r.start.line && acc.column < r.start.column) ? acc : r.start, rs[0].start),
+        end: rs.reduce((acc, r) => acc.line > r.end.line || (acc.line === r.end.line && acc.column > r.end.column) ? acc : r.end, rs[0].end)
+    };
+}
+exports.mergeRanges = mergeRanges;
+/**
+ * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
+ */
+function rangeStartsCompletelyBefore(r1, r2) {
+    return r1.end.line < r2.start.line || (r1.end.line === r2.start.line && r1.end.column < r2.start.column);
+}
+exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
+/**
+ * Checks if the two ranges overlap.
+ */
+function rangesOverlap(r1, r2) {
+    return r1.start.line <= r2.end.line && r2.start.line <= r1.end.line && r1.start.column <= r2.end.column && r2.start.column <= r1.end.column;
+}
+exports.rangesOverlap = rangesOverlap;
+function addRanges(r1, r2) {
+    return rangeFrom(r1.start.line + r2.start.line, r1.start.column + r2.start.column, r1.end.line + r2.end.line, r1.end.column + r2.end.column);
+}
+exports.addRanges = addRanges;
+/**
+ * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.
+ *
+ * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
+ */
+function rangeCompare(r1, r2) {
+    if (r1.start.line === r2.start.line) {
+        return r1.start.column - r2.start.column;
+    }
+    else {
+        return r1.start.line - r2.start.line;
+    }
+}
+exports.rangeCompare = rangeCompare;
+//# sourceMappingURL=range.js.map

package/util/set.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Given both sets, this checks if they contain the same elements.
+ */
+export declare function setEquals<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean;
+/**
+ * Returns `A – B`
+ */
+export declare function setMinus<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): Set<T>;