@traqula/rules-sparql-1-1 0.0.21 → 0.0.22

package/dist/cjs/lib/MinimalSparqlParser.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MinimalSparqlParser_exports = {};
+__export(MinimalSparqlParser_exports, {
+  MinimalSparqlParser: () => MinimalSparqlParser,
+  completeParseContext: () => completeParseContext
+});
+module.exports = __toCommonJS(MinimalSparqlParser_exports);
+var import_core = require("@traqula/core");
+var import_astFactory = require("./astFactory.js");
+function completeParseContext(context) {
+  return {
+    astFactory: context.astFactory ?? new import_astFactory.AstFactory(),
+    baseIRI: context.baseIRI,
+    prefixes: { ...context.prefixes },
+    origSource: context.origSource ?? "",
+    offset: context.offset,
+    parseMode: context.parseMode ? new Set(context.parseMode) : /* @__PURE__ */ new Set(["canParseVars", "canCreateBlankNodes"]),
+    skipValidation: context.skipValidation ?? false,
+    [import_core.traqulaIndentation]: context[import_core.traqulaIndentation] ?? 0,
+    indentInc: context.indentInc ?? 2
+  };
+}
+class MinimalSparqlParser {
+  parser;
+  constructor(parser) {
+    this.parser = parser;
+  }
+  F = new import_astFactory.AstFactory();
+  parse(query, context = {}) {
+    return this.parser.queryOrUpdate(query, completeParseContext(context));
+  }
+  parsePath(query, context = {}) {
+    const result = this.parser.path(query, completeParseContext(context));
+    if (this.F.isPathPure(result)) {
+      return {
+        ...result,
+        prefixes: {}
+      };
+    }
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MinimalSparqlParser,
+  completeParseContext
+});

package/dist/cjs/lib/Sparql11types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Sparql11types_exports = {};
+module.exports = __toCommonJS(Sparql11types_exports);

package/dist/cjs/lib/astFactory.js

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var astFactory_exports = {};
+__export(astFactory_exports, {
+  AstFactory: () => AstFactory
+});
+module.exports = __toCommonJS(astFactory_exports);
+var import_core = require("@traqula/core");
+var import_ContextFactory = require("./factoryMixins/ContextFactory.js");
+var import_ExpressionFactory = require("./factoryMixins/ExpressionFactory.js");
+var import_GraphRefFactory = require("./factoryMixins/GraphRefFactory.js");
+var import_mixins = require("./factoryMixins/mixins.js");
+var import_PathFactory = require("./factoryMixins/PathFactory.js");
+var import_Patternfactory = require("./factoryMixins/Patternfactory.js");
+var import_QueryFactory = require("./factoryMixins/QueryFactory.js");
+var import_SolutionModifiersFactory = require("./factoryMixins/SolutionModifiersFactory.js");
+var import_TermFactory = require("./factoryMixins/TermFactory.js");
+var import_UpdateOperationFactory = require("./factoryMixins/UpdateOperationFactory.js");
+class AstFactory extends (0, import_mixins.asArg)(import_core.AstCoreFactory).call(import_ContextFactory.ContextFactoryMixin).call(import_ExpressionFactory.ExpressionFactoryMixin).call(import_GraphRefFactory.GraphRefFactoryMixin).call(import_PathFactory.PathFactoryMixin).call(import_Patternfactory.PatternFactoryMixin).call(import_QueryFactory.QueryFactoryMixin).call(import_SolutionModifiersFactory.SolutionModifiersFactoryMixin).call(import_TermFactory.TermFactoryMixin).call(import_UpdateOperationFactory.UpdateOperationFactoryMixin).returns() {
+  alwaysSparql11(obj) {
+    return true;
+  }
+  isPath(obj) {
+    return this.isPathPure(obj) || this.isTermNamed(obj);
+  }
+  isExpression(obj) {
+    return this.isExpressionPure(obj) || this.isTermNamed(obj) || this.isTermVariable(obj) || this.isTermLiteral(obj);
+  }
+  graphNodeIdentifier(graphNode) {
+    return graphNode.type === "tripleCollection" ? graphNode.identifier : graphNode;
+  }
+  triple(subject, predicate, object, loc) {
+    return {
+      type: "triple",
+      subject,
+      predicate,
+      object,
+      loc: loc ?? this.sourceLocation(subject, predicate, object)
+    };
+  }
+  isTriple(obj) {
+    return this.isOfType(obj, "triple");
+  }
+  datasetClauses(clauses, loc) {
+    return {
+      type: "datasetClauses",
+      clauses,
+      loc
+    };
+  }
+  isDatasetClauses(obj) {
+    return this.isOfType(obj, "datasetClauses");
+  }
+  wildcard(loc) {
+    return { type: "wildcard", loc };
+  }
+  isWildcard(obj) {
+    return this.isOfType(obj, "wildcard");
+  }
+  isTripleCollection(obj) {
+    return this.isOfType(obj, "tripleCollection");
+  }
+  tripleCollectionBlankNodeProperties(identifier, triples, loc) {
+    return {
+      type: "tripleCollection",
+      subType: "blankNodeProperties",
+      identifier,
+      triples,
+      loc
+    };
+  }
+  isTripleCollectionBlankNodeProperties(obj) {
+    return this.isOfSubType(obj, "tripleCollection", "blankNodeProperties");
+  }
+  tripleCollectionList(identifier, triples, loc) {
+    return {
+      type: "tripleCollection",
+      subType: "list",
+      identifier,
+      triples,
+      loc
+    };
+  }
+  isTripleCollectionList(obj) {
+    return this.isOfSubType(obj, "tripleCollection", "list");
+  }
+  graphQuads(graph, triples, loc) {
+    return {
+      type: "graph",
+      graph,
+      triples,
+      loc
+    };
+  }
+  isGraphQuads(obj) {
+    return super.isOfType(obj, "graph");
+  }
+  isUpdate(obj) {
+    return super.isOfType(obj, "update");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AstFactory
+});

package/dist/cjs/lib/expressionHelpers.js

@@ -0,0 +1,215 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expressionHelpers_exports = {};
+__export(expressionHelpers_exports, {
+  baseAggregateFunc: () => baseAggregateFunc,
+  funcExpr1: () => funcExpr1,
+  funcExpr2: () => funcExpr2,
+  funcExpr2or3: () => funcExpr2or3,
+  funcExpr3: () => funcExpr3,
+  funcExpr3or4: () => funcExpr3or4,
+  funcExprList1: () => funcExprList1,
+  funcExprOrNil1: () => funcExprOrNil1,
+  funcGroupGraphPattern: () => funcGroupGraphPattern,
+  funcNil1: () => funcNil1,
+  funcVar1: () => funcVar1
+});
+module.exports = __toCommonJS(expressionHelpers_exports);
+var import_core = require("@traqula/core");
+var import_grammar = require("./grammar/index.js");
+var l = __toESM(require("./lexer/index.js"), 1);
+function funcExpr1(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg = SUBRULE(import_grammar.expression);
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcExpr2(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg1 = SUBRULE1(import_grammar.expression);
+      CONSUME(l.symbols.comma);
+      const arg2 = SUBRULE2(import_grammar.expression);
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcExpr3(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, CONSUME1, CONSUME2, SUBRULE1, SUBRULE2, SUBRULE3 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg1 = SUBRULE1(import_grammar.expression);
+      CONSUME1(l.symbols.comma);
+      const arg2 = SUBRULE2(import_grammar.expression);
+      CONSUME2(l.symbols.comma);
+      const arg3 = SUBRULE3(import_grammar.expression);
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcVar1(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg = SUBRULE(import_grammar.var_);
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcExprOrNil1(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, OR, SUBRULE }) => (C) => {
+      const operator = CONSUME(func);
+      return OR([
+        { ALT: () => {
+          CONSUME(l.symbols.LParen);
+          const arg = SUBRULE(import_grammar.expression);
+          const close = CONSUME(l.symbols.RParen);
+          return ACTION(() => C.astFactory.expressionOperation(operator.image, [arg], C.astFactory.sourceLocation(operator, close)));
+        } },
+        { ALT: () => {
+          const nil = CONSUME(l.terminals.nil);
+          return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil)));
+        } }
+      ]);
+    }
+  };
+}
+function funcNil1(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      const nil = CONSUME(l.terminals.nil);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, [], C.astFactory.sourceLocation(operator, nil)));
+    }
+  };
+}
+function funcExprList1(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE }) => (C) => {
+      const operator = CONSUME(func);
+      const args = SUBRULE(import_grammar.expressionList);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, args.val, C.astFactory.sourceLocation(operator, args)));
+    }
+  };
+}
+function funcExpr2or3(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, CONSUME1, OPTION, CONSUME2 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg1 = SUBRULE1(import_grammar.expression);
+      CONSUME1(l.symbols.comma);
+      const arg2 = SUBRULE2(import_grammar.expression);
+      const arg3 = OPTION(() => {
+        CONSUME2(l.symbols.comma);
+        return SUBRULE3(import_grammar.expression);
+      });
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, arg3 ? [arg1, arg2, arg3] : [arg1, arg2], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcExpr3or4(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE1, SUBRULE2, SUBRULE3, SUBRULE4, CONSUME1, OPTION, CONSUME2, CONSUME3 }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const arg1 = SUBRULE1(import_grammar.expression);
+      CONSUME1(l.symbols.comma);
+      const arg2 = SUBRULE2(import_grammar.expression);
+      CONSUME2(l.symbols.comma);
+      const arg3 = SUBRULE3(import_grammar.expression);
+      const arg4 = OPTION(() => {
+        CONSUME3(l.symbols.comma);
+        return SUBRULE4(import_grammar.expression);
+      });
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.expressionOperation(operator.image, arg4 ? [arg1, arg2, arg3, arg4] : [arg1, arg2, arg3], C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+function funcGroupGraphPattern(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, SUBRULE, CONSUME }) => (C) => {
+      const operator = CONSUME(func);
+      const group = SUBRULE(import_grammar.groupGraphPattern);
+      return ACTION(() => C.astFactory.expressionPatternOperation(operator.image, group, C.astFactory.sourceLocation(operator, group)));
+    }
+  };
+}
+function baseAggregateFunc(func) {
+  return {
+    name: (0, import_core.unCapitalize)(func.name),
+    impl: ({ ACTION, CONSUME, SUBRULE, OPTION }) => (C) => {
+      const operator = CONSUME(func);
+      CONSUME(l.symbols.LParen);
+      const distinct = OPTION(() => CONSUME(l.distinct));
+      const expr1 = SUBRULE(import_grammar.expression);
+      const close = CONSUME(l.symbols.RParen);
+      return ACTION(() => C.astFactory.aggregate(operator.image, distinct !== void 0, expr1, void 0, C.astFactory.sourceLocation(operator, close)));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baseAggregateFunc,
+  funcExpr1,
+  funcExpr2,
+  funcExpr2or3,
+  funcExpr3,
+  funcExpr3or4,
+  funcExprList1,
+  funcExprOrNil1,
+  funcGroupGraphPattern,
+  funcNil1,
+  funcVar1
+});

package/dist/cjs/lib/factoryMixins/ContextFactory.js

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ContextFactory_exports = {};
+__export(ContextFactory_exports, {
+  ContextFactoryMixin: () => ContextFactoryMixin
+});
+module.exports = __toCommonJS(ContextFactory_exports);
+const nodeType = "contextDef";
+function ContextFactoryMixin(Base) {
+  return class ContextFactory extends Base {
+    contextDefinitionPrefix(loc, key, value) {
+      return {
+        type: nodeType,
+        subType: "prefix",
+        key,
+        value,
+        loc
+      };
+    }
+    isContextDefinitionPrefix(contextDef) {
+      return this.isOfSubType(contextDef, nodeType, "prefix");
+    }
+    contextDefinitionBase(loc, value) {
+      return {
+        type: "contextDef",
+        subType: "base",
+        value,
+        loc
+      };
+    }
+    isContextDefinitionBase(contextDef) {
+      return this.isOfSubType(contextDef, nodeType, "base");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/ExpressionFactory.js

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ExpressionFactory_exports = {};
+__export(ExpressionFactory_exports, {
+  ExpressionFactoryMixin: () => ExpressionFactoryMixin
+});
+module.exports = __toCommonJS(ExpressionFactory_exports);
+const nodeType = "expression";
+function ExpressionFactoryMixin(Base) {
+  return class ExpressionFactory extends Base {
+    isExpressionPure(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    formatOperator(operator) {
+      return operator.toLowerCase().replaceAll(" ", "");
+    }
+    expressionOperation(operator, args, loc) {
+      return {
+        type: nodeType,
+        subType: "operation",
+        operator: this.formatOperator(operator),
+        args,
+        loc
+      };
+    }
+    isExpressionOperator(obj) {
+      return this.isOfSubType(obj, nodeType, "operation");
+    }
+    expressionFunctionCall(functionOp, args, distinct, loc) {
+      return {
+        type: "expression",
+        subType: "functionCall",
+        function: functionOp,
+        args,
+        distinct,
+        loc
+      };
+    }
+    isExpressionFunctionCall(obj) {
+      return this.isOfSubType(obj, nodeType, "functionCall");
+    }
+    expressionPatternOperation(operator, args, loc) {
+      return {
+        type: nodeType,
+        subType: "patternOperation",
+        operator: this.formatOperator(operator),
+        args,
+        loc
+      };
+    }
+    isExpressionPatternOperation(obj) {
+      return this.isOfSubType(obj, nodeType, "patternOperation");
+    }
+    aggregate(aggregation, distinct, arg, separator, loc) {
+      const base = {
+        type: "expression",
+        subType: "aggregate",
+        aggregation: this.formatOperator(aggregation),
+        distinct,
+        loc
+      };
+      if (this.isOfType(arg, "wildcard")) {
+        return { ...base, expression: [arg] };
+      }
+      if (separator === void 0) {
+        return { ...base, expression: [arg] };
+      }
+      return { ...base, expression: [arg], separator };
+    }
+    isExpressionAggregate(obj) {
+      return this.isOfSubType(obj, nodeType, "aggregate");
+    }
+    isExpressionAggregateSeparator(obj) {
+      return this.isOfSubType(obj, nodeType, "aggregate") && typeof obj.separator === "string";
+    }
+    isExpressionAggregateOnWildcard(obj) {
+      const casted = obj;
+      return this.isOfSubType(obj, nodeType, "aggregate") && Array.isArray(casted.expression) && casted.expression.length === 1 && this.isOfType(casted.expression[0], "wildcard");
+    }
+    isExpressionAggregateDefault(obj) {
+      const casted = obj;
+      return this.isOfSubType(obj, nodeType, "operation") && Array.isArray(casted.expression) && casted.expression.length === 1 && !this.isOfType(casted.expression[0], "wildcard");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExpressionFactoryMixin
+});

package/dist/cjs/lib/factoryMixins/GraphRefFactory.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var GraphRefFactory_exports = {};
+__export(GraphRefFactory_exports, {
+  GraphRefFactoryMixin: () => GraphRefFactoryMixin
+});
+module.exports = __toCommonJS(GraphRefFactory_exports);
+const nodeType = "graphRef";
+function GraphRefFactoryMixin(Base) {
+  return class GraphRefFactory extends Base {
+    isGraphRef(obj) {
+      return this.isOfType(obj, nodeType);
+    }
+    graphRefDefault(loc) {
+      return {
+        type: nodeType,
+        subType: "default",
+        loc
+      };
+    }
+    isGraphRefDefault(graphRef) {
+      return this.isOfSubType(graphRef, nodeType, "default");
+    }
+    graphRefNamed(loc) {
+      return {
+        type: nodeType,
+        subType: "named",
+        loc
+      };
+    }
+    isGraphRefNamed(graphRef) {
+      return this.isOfSubType(graphRef, nodeType, "named");
+    }
+    graphRefAll(loc) {
+      return {
+        type: nodeType,
+        subType: "all",
+        loc
+      };
+    }
+    isGraphRefAll(graphRef) {
+      return this.isOfSubType(graphRef, nodeType, "all");
+    }
+    graphRefSpecific(graph, loc) {
+      return {
+        type: nodeType,
+        subType: "specific",
+        graph,
+        loc
+      };
+    }
+    isGraphRefSpecific(graphRef) {
+      return this.isOfSubType(graphRef, nodeType, "specific");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GraphRefFactoryMixin
+});