@eagleoutice/flowr 2.7.0 → 2.7.3

package/abstract-interpretation/data-frame/absint-info.d.ts

@@ -1,109 +0,0 @@
-import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataFrameStateDomain } from './dataframe-domain';
-import type { ConstraintType, DataFrameOperationArgs, DataFrameOperationName, DataFrameOperationOptions } from './semantics';
-/**
- * An abstract data frame operation without additional options.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperationType<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * An abstract data frame operation.
- * - `operation` contains the type of the abstract operation (see {@link DataFrameOperationName})
- * - `operand` contains the ID of the data frame operand of the operation (may be `undefined`)
- * - `type` optionally contains the constraint type to overwrite the default type of the operation (see {@link ConstraintType})
- * - `options` optionally contains additional options for the abstract operation (see {@link DataFrameOperationOptions})
- * - `...args` contains the arguments of the abstract operation (see {@link DataFrameOperationArgs})
- */
-export type DataFrameOperation<OperationName extends DataFrameOperationName = DataFrameOperationName> = {
-    [Name in OperationName]: {
-        operation: Name;
-        operand: NodeId | undefined;
-        type?: ConstraintType;
-        options?: DataFrameOperationOptions<Name>;
-    } & DataFrameOperationArgs<Name>;
-}[OperationName];
-/**
- * Represents the base data frame information stored in the abstract interpretation info of an AST node.
- * - `type` optionally defines the type of the extra information stored in the data frame info
- * - `domain` contains the abstract data frame shape state of the node
- *   This may not be present if the data frame shape inference has not been executed yet or the program contains no data frames
- */
-interface DataFrameInfoBase {
-    type?: string;
-    domain?: DataFrameStateDomain;
-}
-/** Enum to mark nodes during the data frame shape inference */
-export declare enum DataFrameInfoMarker {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    Unassigned = "unassigned"
-}
-/**
- * Represents the data frame information for a node without extra data frame information,
- * i.e. for all nodes that do not represent a data frame assignment or data frame operation (this is the default).
- *
- * The `marker` can be used to mark nodes during the data frame shape inference.
- */
-interface DataFrameEmptyInfo extends DataFrameInfoBase {
-    type?: never;
-    marker?: DataFrameInfoMarker;
-}
-/**
- * Represents the data frame information for a data frame assignment with a target identifier (symbol/string) and an assigned expression.
- * This is used during data frame shape inference to mark assignments of data frame expressions to an identifier.
- *
- * Use {@link hasDataFrameAssignmentInfo} to check whether an AST node has attached data frame assignment information.
- */
-export interface DataFrameAssignmentInfo extends DataFrameInfoBase {
-    type: 'assignment';
-    identifier: NodeId;
-    expression: NodeId;
-}
-/**
- * Represents the data frame information for a data frame function/operation with mapped abstract operations.
- * This is used during data frame shape inference to store the abstract operations a data frame function/operation is mapped to.
- *
- * The order of the abstract operations is the order in which their semantics are applied (for example, access operations are typically before other operations in the list).
- * Moreover, abstract operations that take the result of previous abstract operation as data frame operand must have the `operand` set to `undefined`.
- *
- * Use {@link hasDataFrameExpressionInfo} to check whether an AST node has attached data frame expression information.
- */
-export interface DataFrameExpressionInfo extends DataFrameInfoBase {
-    type: 'expression';
-    operations: DataFrameOperation[];
-}
-/**
- * Represents the data frame shape inference information stored in the abstract interpretation info of AST nodes.
- */
-export type DataFrameInfo = DataFrameEmptyInfo | DataFrameAssignmentInfo | DataFrameExpressionInfo;
-/**
- * Represents the abstract interpretation information attached to AST nodes.
- */
-export interface AbstractInterpretationInfo {
-    dataFrame?: DataFrameInfo;
-}
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-export declare function hasDataFrameAssignmentInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameAssignmentInfo;
-}>;
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-export declare function hasDataFrameExpressionInfo<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>): node is RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo & {
-    dataFrame: DataFrameExpressionInfo;
-}>;
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-export declare function hasDataFrameInfoMarker<OtherInfo>(node: RNode<OtherInfo & ParentInformation & AbstractInterpretationInfo>, marker: DataFrameInfoMarker): boolean;
-export {};

package/abstract-interpretation/data-frame/absint-info.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameInfoMarker = void 0;
-exports.hasDataFrameAssignmentInfo = hasDataFrameAssignmentInfo;
-exports.hasDataFrameExpressionInfo = hasDataFrameExpressionInfo;
-exports.hasDataFrameInfoMarker = hasDataFrameInfoMarker;
-/** Enum to mark nodes during the data frame shape inference */
-var DataFrameInfoMarker;
-(function (DataFrameInfoMarker) {
-    /** Marks the target symbol of assignments as "unassigned" until the assigned expression is evaluated */
-    DataFrameInfoMarker["Unassigned"] = "unassigned";
-})(DataFrameInfoMarker || (exports.DataFrameInfoMarker = DataFrameInfoMarker = {}));
-/**
- * Checks whether an AST node has attached data frame assignment information.
- */
-function hasDataFrameAssignmentInfo(node) {
-    return node.info.dataFrame?.type === 'assignment';
-}
-/**
- * Checks whether an AST node has attached data frame expression information.
- */
-function hasDataFrameExpressionInfo(node) {
-    return node.info.dataFrame?.type === 'expression';
-}
-/**
- * Checks whether an AST node has an attached data frame info marker.
- */
-function hasDataFrameInfoMarker(node, marker) {
-    return node.info.dataFrame?.type === undefined && node.info.dataFrame?.marker === marker;
-}
-//# sourceMappingURL=absint-info.js.map

package/abstract-interpretation/data-frame/absint-visitor.d.ts

@@ -1,57 +0,0 @@
-import { type CfgBasicBlockVertex, type CfgSimpleVertex, type ControlFlowInformation } from '../../control-flow/control-flow-graph';
-import { SemanticCfgGuidedVisitor, type SemanticCfgGuidedVisitorConfiguration } from '../../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraph } from '../../dataflow/graph/graph';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexVariableDefinition } from '../../dataflow/graph/vertex';
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
-import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { type AbstractInterpretationInfo } from './absint-info';
-export type DataFrameShapeInferenceVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph> = Omit<SemanticCfgGuidedVisitorConfiguration<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg>, 'defaultVisitingOrder' | 'defaultVisitingType'>;
-/**
- * The control flow graph visitor to infer the shape of data frames using abstract interpretation
- */
-export declare class DataFrameShapeInferenceVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>, Dfg extends DataflowGraph = DataflowGraph, Config extends DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>> extends SemanticCfgGuidedVisitor<OtherInfo & AbstractInterpretationInfo, ControlFlow, Ast, Dfg, Config & {
-    defaultVisitingOrder: 'forward';
-    defaultVisitingType: 'exit';
-}> {
-    /**
-     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
-     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
-     */
-    private oldDomain;
-    /**
-     * The new domain of an AST node during and after processing the node.
-     * This information is stored in the {@link AbstractInterpretationInfo} afterward.
-     */
-    private newDomain;
-    constructor(config: Config);
-    protected visitNode(nodeId: NodeId): boolean;
-    protected visitDataflowNode(vertex: Exclude<CfgSimpleVertex, CfgBasicBlockVertex>): void;
-    protected onVariableDefinition({ vertex }: {
-        vertex: DataflowGraphVertexVariableDefinition;
-    }): void;
-    protected onAssignmentCall({ call, target, source }: {
-        call: DataflowGraphVertexFunctionCall;
-        target?: NodeId;
-        source?: NodeId;
-    }): void;
-    protected onAccessCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onDefaultFunctionCall({ call }: {
-        call: DataflowGraphVertexFunctionCall;
-    }): void;
-    protected onReplacementCall({ call, source, target }: {
-        call: DataflowGraphVertexFunctionCall;
-        source: NodeId | undefined;
-        target: NodeId | undefined;
-    }): void;
-    private applyDataFrameAssignment;
-    private applyDataFrameExpression;
-    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
-    private shouldSkipVertex;
-    /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
-    private getPredecessorNodes;
-    private shouldWiden;
-    private clearUnassignedInfo;
-}

package/abstract-interpretation/data-frame/absint-visitor.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFrameShapeInferenceVisitor = void 0;
-const control_flow_graph_1 = require("../../control-flow/control-flow-graph");
-const semantic_cfg_guided_visitor_1 = require("../../control-flow/semantic-cfg-guided-visitor");
-const assert_1 = require("../../util/assert");
-const absint_info_1 = require("./absint-info");
-const dataframe_domain_1 = require("./dataframe-domain");
-const access_mapper_1 = require("./mappers/access-mapper");
-const assignment_mapper_1 = require("./mappers/assignment-mapper");
-const function_mapper_1 = require("./mappers/function-mapper");
-const replacement_mapper_1 = require("./mappers/replacement-mapper");
-const semantics_1 = require("./semantics");
-const shape_inference_1 = require("./shape-inference");
-/**
- * The control flow graph visitor to infer the shape of data frames using abstract interpretation
- */
-class DataFrameShapeInferenceVisitor extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
-    /**
-     * The old domain of an AST node before processing the node retrieved from the attached {@link AbstractInterpretationInfo}.
-     * This is used to check whether the state has changed and successors should be visited again, and is also required for widening.
-     */
-    oldDomain = dataframe_domain_1.DataFrameStateDomain.bottom();
-    /**
-     * The new domain of an AST node during and after processing the node.
-     * This information is stored in the {@link AbstractInterpretationInfo} afterward.
-     */
-    newDomain = dataframe_domain_1.DataFrameStateDomain.bottom();
-    constructor(config) {
-        super({ ...config, defaultVisitingOrder: 'forward', defaultVisitingType: 'exit' });
-    }
-    visitNode(nodeId) {
-        const vertex = this.getCfgVertex(nodeId);
-        // skip vertices representing entries of complex nodes
-        if (vertex === undefined || this.shouldSkipVertex(vertex)) {
-            return true;
-        }
-        const predecessors = this.getPredecessorNodes(vertex.id);
-        const predecessorDomains = predecessors.map(node => node.info.dataFrame?.domain).filter(assert_1.isNotUndefined);
-        this.newDomain = dataframe_domain_1.DataFrameStateDomain.bottom().joinAll(predecessorDomains);
-        this.onVisitNode(nodeId);
-        const visitedCount = this.visited.get(vertex.id) ?? 0;
-        this.visited.set(vertex.id, visitedCount + 1);
-        // only continue visiting if the node has not been visited before or the data frame value of the node changed
-        return visitedCount === 0 || !this.oldDomain.equals(this.newDomain);
-    }
-    visitDataflowNode(vertex) {
-        const node = this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex));
-        if (node === undefined) {
-            return;
-        }
-        this.oldDomain = node.info.dataFrame?.domain ?? dataframe_domain_1.DataFrameStateDomain.bottom();
-        super.visitDataflowNode(vertex);
-        if (this.config.dfg.unknownSideEffects.has((0, control_flow_graph_1.getVertexRootId)(vertex))) {
-            this.newDomain = this.newDomain.bottom();
-        }
-        if (this.shouldWiden(vertex)) {
-            this.newDomain = this.oldDomain.widen(this.newDomain);
-        }
-        node.info.dataFrame ??= {};
-        node.info.dataFrame.domain = this.newDomain;
-    }
-    onVariableDefinition({ vertex }) {
-        const node = this.getNormalizedAst(vertex.id);
-        if (node !== undefined) {
-            // mark variable definitions as "unassigned", as the evaluation of the assigned expression is delayed until processing the assignment
-            node.info.dataFrame ??= { marker: absint_info_1.DataFrameInfoMarker.Unassigned };
-        }
-    }
-    onAssignmentCall({ call, target, source }) {
-        const node = this.getNormalizedAst(call.id);
-        const targetNode = this.getNormalizedAst(target);
-        const sourceNode = this.getNormalizedAst(source);
-        if (node !== undefined && (0, assignment_mapper_1.isAssignmentTarget)(targetNode) && sourceNode !== undefined) {
-            node.info.dataFrame = (0, assignment_mapper_1.mapDataFrameVariableAssignment)(targetNode, sourceNode, this.config.dfg, this.config.ctx);
-            this.applyDataFrameAssignment(node);
-            this.clearUnassignedInfo(targetNode);
-        }
-    }
-    onAccessCall({ call }) {
-        const node = this.getNormalizedAst(call.id);
-        if (node !== undefined) {
-            node.info.dataFrame = (0, access_mapper_1.mapDataFrameAccess)(node, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-        }
-    }
-    onDefaultFunctionCall({ call }) {
-        const node = this.getNormalizedAst(call.id);
-        if (node !== undefined) {
-            node.info.dataFrame = (0, function_mapper_1.mapDataFrameFunctionCall)(node, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-        }
-    }
-    onReplacementCall({ call, source, target }) {
-        const node = this.getNormalizedAst(call.id);
-        const targetNode = this.getNormalizedAst(target);
-        const sourceNode = this.getNormalizedAst(source);
-        if (node !== undefined && targetNode !== undefined && sourceNode !== undefined) {
-            node.info.dataFrame = (0, replacement_mapper_1.mapDataFrameReplacementFunction)(node, sourceNode, this.config.dfg, this.config.ctx);
-            this.applyDataFrameExpression(node);
-            this.clearUnassignedInfo(targetNode);
-        }
-    }
-    applyDataFrameAssignment(node) {
-        if (!(0, absint_info_1.hasDataFrameAssignmentInfo)(node)) {
-            return;
-        }
-        const value = (0, shape_inference_1.resolveIdToDataFrameShape)(node.info.dataFrame.expression, this.config.dfg, this.newDomain);
-        if (value !== undefined) {
-            this.newDomain.set(node.info.dataFrame.identifier, value);
-            const identifier = this.getNormalizedAst(node.info.dataFrame.identifier);
-            if (identifier !== undefined) {
-                identifier.info.dataFrame ??= {};
-                identifier.info.dataFrame.domain = this.newDomain.create(this.newDomain.value);
-            }
-        }
-    }
-    applyDataFrameExpression(node) {
-        if (!(0, absint_info_1.hasDataFrameExpressionInfo)(node)) {
-            return;
-        }
-        const maxColNames = this.config.ctx.config.abstractInterpretation.dataFrame.maxColNames;
-        let value = dataframe_domain_1.DataFrameDomain.top(maxColNames);
-        for (const { operation, operand, type, options, ...args } of node.info.dataFrame.operations) {
-            const operandValue = operand !== undefined ? (0, shape_inference_1.resolveIdToDataFrameShape)(operand, this.config.dfg, this.newDomain) : value;
-            value = (0, semantics_1.applyDataFrameSemantics)(operation, operandValue ?? dataframe_domain_1.DataFrameDomain.top(maxColNames), args, options);
-            const constraintType = type ?? (0, semantics_1.getConstraintType)(operation);
-            if (operand !== undefined && constraintType === semantics_1.ConstraintType.OperandModification) {
-                this.newDomain.set(operand, value);
-                for (const origin of (0, shape_inference_1.getVariableOrigins)(operand, this.config.dfg)) {
-                    this.newDomain.set(origin.info.id, value);
-                }
-            }
-            else if (constraintType === semantics_1.ConstraintType.ResultPostcondition) {
-                this.newDomain.set(node.info.id, value);
-            }
-        }
-    }
-    /** We only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes) */
-    shouldSkipVertex(vertex) {
-        return (0, control_flow_graph_1.isMarkerVertex)(vertex) ? vertex.type !== control_flow_graph_1.CfgVertexType.EndMarker : vertex.end !== undefined;
-    }
-    /** Get all AST nodes for the predecessor vertices that are leaf nodes and exit vertices */
-    getPredecessorNodes(vertexId) {
-        return this.config.controlFlow.graph.outgoingEdges(vertexId)?.keys() // outgoing dependency edges are incoming CFG edges
-            .map(id => this.getCfgVertex(id))
-            .flatMap(vertex => {
-            if (vertex === undefined) {
-                return [];
-            }
-            else if (this.shouldSkipVertex(vertex)) {
-                return this.getPredecessorNodes(vertex.id);
-            }
-            else {
-                return [this.getNormalizedAst((0, control_flow_graph_1.getVertexRootId)(vertex))];
-            }
-        })
-            .filter(assert_1.isNotUndefined)
-            .toArray() ?? [];
-    }
-    shouldWiden(vertex) {
-        return (this.visited.get(vertex.id) ?? 0) >= this.config.ctx.config.abstractInterpretation.dataFrame.wideningThreshold;
-    }
-    clearUnassignedInfo(node) {
-        if ((0, absint_info_1.hasDataFrameInfoMarker)(node, absint_info_1.DataFrameInfoMarker.Unassigned)) {
-            if (node.info.dataFrame?.domain !== undefined) {
-                node.info.dataFrame = { domain: node.info.dataFrame.domain };
-            }
-            else {
-                delete node.info.dataFrame;
-            }
-        }
-    }
-}
-exports.DataFrameShapeInferenceVisitor = DataFrameShapeInferenceVisitor;
-//# sourceMappingURL=absint-visitor.js.map

package/abstract-interpretation/data-frame/mappers/assignment-mapper.d.ts

@@ -1,21 +0,0 @@
-import type { DataflowGraph } from '../../../dataflow/graph/graph';
-import type { RNode } from '../../../r-bridge/lang-4.x/ast/model/model';
-import type { RString } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataFrameAssignmentInfo } from '../absint-info';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
-/**
- * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
- * We currently do not support function assignments dealing with data frames.
- * @param identifier - The R node of the variable identifier
- * @param expression - The R node of the assigned expression
- * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx - The analysis context
- * @returns Data frame assignment info containing the IDs of the identifier and expression, or `undefined` if the node does not represent a data frame assignment
- */
-export declare function mapDataFrameVariableAssignment(identifier: RSymbol<ParentInformation> | RString<ParentInformation>, expression: RNode<ParentInformation>, dfg: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): DataFrameAssignmentInfo | undefined;
-/**
- * Checks whether a R node represents an assignment target, i.e. is a `RSymbol` or `RString`.
- */
-export declare function isAssignmentTarget(node: RNode<ParentInformation> | undefined): node is RSymbol<ParentInformation> | RString<ParentInformation>;

package/abstract-interpretation/data-frame/mappers/assignment-mapper.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapDataFrameVariableAssignment = mapDataFrameVariableAssignment;
-exports.isAssignmentTarget = isAssignmentTarget;
-const config_1 = require("../../../config");
-const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
-const arguments_1 = require("./arguments");
-/**
- * Maps a concrete data frame assignment to data frame assignment info containing the ids of the identifier and assigned expression.
- * We currently do not support function assignments dealing with data frames.
- * @param identifier - The R node of the variable identifier
- * @param expression - The R node of the assigned expression
- * @param dfg  - The data flow graph for resolving the arguments
- * @param ctx - The analysis context
- * @returns Data frame assignment info containing the IDs of the identifier and expression, or `undefined` if the node does not represent a data frame assignment
- */
-function mapDataFrameVariableAssignment(identifier, expression, dfg, ctx) {
-    const resolveInfo = { graph: dfg, idMap: dfg.idMap, full: true, resolve: config_1.VariableResolve.Alias, ctx };
-    if (!(0, arguments_1.isDataFrameArgument)(expression, resolveInfo)) {
-        return;
-    }
-    return {
-        type: 'assignment',
-        identifier: identifier.info.id,
-        expression: expression.info.id
-    };
-}
-/**
- * Checks whether a R node represents an assignment target, i.e. is a `RSymbol` or `RString`.
- */
-function isAssignmentTarget(node) {
-    return node?.type === type_1.RType.Symbol || node?.type === type_1.RType.String;
-}
-//# sourceMappingURL=assignment-mapper.js.map

package/documentation/doc-util/doc-print.d.ts

@@ -1,5 +0,0 @@
-/**
- * Writes the wiki documentation to the specified output path.
- * Returns true if the file was updated, false if it was unchanged.
- */
-export declare function writeWikiTo(text: string, output_path: string, check_change?: boolean): boolean;

package/documentation/doc-util/doc-print.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeWikiTo = writeWikiTo;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-/* eslint-disable */
-const IgnoreRegex = /[0-9]+(\.[0-9]+)? ?ms|"timing":\s*[0-9]+(\.0-9)?,?|tmp-[A-Za-z0-9-]+/g;
-/* eslint-enable */
-/**
- * Checks whether the file contains a different content, but ignores timing and some other non-semantic changes.
- */
-function didFileChange(filePath, content) {
-    if (!fs_1.default.existsSync(filePath)) {
-        return true; // If the file does not exist, it is considered changed.
-    }
-    const currentContent = fs_1.default.readFileSync(filePath, 'utf-8');
-    const cleanedCurrentContent = currentContent.replace(IgnoreRegex, '');
-    const cleanedNewContent = content.replace(IgnoreRegex, '');
-    return cleanedCurrentContent !== cleanedNewContent;
-}
-/**
- * Writes the wiki documentation to the specified output path.
- * Returns true if the file was updated, false if it was unchanged.
- */
-function writeWikiTo(text, output_path, check_change = true) {
-    if (!check_change || didFileChange(output_path, text)) {
-        fs_1.default.mkdirSync(path_1.default.dirname(output_path), { recursive: true });
-        fs_1.default.writeFileSync(output_path, text, 'utf-8');
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=doc-print.js.map

package/project/plugins/file-plugins/flowr-description-file.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlowrDescriptionFile = void 0;
-const flowr_file_1 = require("../../context/flowr-file");
-const files_1 = require("../../../util/files");
-/**
- * This decorates a text file and provides access to its content as a DCF (Debian Control File)-like structure.
- */
-class FlowrDescriptionFile extends flowr_file_1.FlowrFile {
-    wrapped;
-    /**
-     * Prefer the static {@link FlowrDescriptionFile.from} method to create instances of this class as it will not re-create if already a description file
-     * and handle role assignments.
-     */
-    constructor(file) {
-        super(file.path(), file.role);
-        this.wrapped = file;
-    }
-    /**
-     * Loads and parses the content of the wrapped file as a DCF structure.
-     * @see {@link parseDCF} for details on the parsing logic.
-     */
-    loadContent() {
-        return (0, files_1.parseDCF)(this.wrapped);
-    }
-    /**
-     * Description file lifter, this does not re-create if already a description file
-     */
-    static from(file, role) {
-        if (role) {
-            file.assignRole(role);
-        }
-        return file instanceof FlowrDescriptionFile ? file : new FlowrDescriptionFile(file);
-    }
-}
-exports.FlowrDescriptionFile = FlowrDescriptionFile;
-//# sourceMappingURL=flowr-description-file.js.map

package/project/plugins/file-plugins/notebooks/notebook.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=notebook.js.map