@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/ShapeMap-C422pxKl.d.mts

@@ -0,0 +1,140 @@
+import { d as NamedNode, p as Object$1, s as GroundTerm, w as Subject } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { l as RdfParseError } from "./Serialization-Df8iVauT.mjs";
+import * as Effect from "effect/Effect";
+declare namespace ShapeMap_d_exports {
+  export { Association, FixedShapeMap, NodeSelector, ParseOptions, QueryAssociation, QueryShapeMap, ShapeSelector, Start, TriplePattern, format, formatShape, fromJson, isStart, parse, parseTerm, resolve, start };
+}
+/**
+ * The `START` shape of a schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Start {
+  readonly _tag: 'Start';
+}
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const start: Start;
+/**
+ * A shape label or `START`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type ShapeSelector = string | Start;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isStart: (s: ShapeSelector) => s is Start;
+/**
+ * A triple pattern selecting focus nodes: exactly one of `subject` and
+ * `object` is `'FOCUS'`; the other is a term or the wildcard `'_'`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface TriplePattern {
+  readonly _tag: 'TriplePattern';
+  readonly subject: Subject | 'FOCUS' | '_';
+  readonly predicate: NamedNode;
+  readonly object: Object$1 | 'FOCUS' | '_';
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+type NodeSelector = GroundTerm | TriplePattern;
+/**
+ * An association in a query shape map.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface QueryAssociation {
+  readonly node: NodeSelector;
+  readonly shape: ShapeSelector;
+}
+/**
+ * An association in a fixed shape map.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Association {
+  readonly node: GroundTerm;
+  readonly shape: ShapeSelector;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+type QueryShapeMap = ReadonlyArray<QueryAssociation>;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+type FixedShapeMap = ReadonlyArray<Association>;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ParseOptions {
+  readonly baseIri?: string | undefined;
+  readonly prefixes?: Readonly<Record<string, string>> | undefined;
+  /** Prefixes used only for shape labels (e.g. those of the schema). */
+  readonly shapePrefixes?: Readonly<Record<string, string>> | undefined;
+}
+/**
+ * Parses a (query) shape map in the compact syntax.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<QueryShapeMap, RdfParseError>;
+/**
+ * Parses a single RDF term in N-Triples / Turtle notation (`<iri>`,
+ * `_:label`, `"lexical"^^<dt>`, …), as used by the JSON form of shape maps.
+ * A bare string that is not a term is taken as an IRI.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parseTerm: (input: string, options?: ParseOptions) => GroundTerm;
+/**
+ * Reads the JSON form of a fixed shape map: an array of
+ * `{ "node": term, "shape": label | "START" }` objects. Node terms use
+ * N-Triples notation or are bare IRIs.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const fromJson: (json: unknown, options?: ParseOptions) => FixedShapeMap;
+/**
+ * Resolves a query shape map against a dataset, producing a fixed shape map
+ * (duplicates removed, order preserved).
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+declare const resolve: (map: QueryShapeMap, dataset: Dataset) => FixedShapeMap;
+/**
+ * Formats a shape selector for display.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatShape: (shape: ShapeSelector) => string;
+/**
+ * Formats a fixed shape map in the compact syntax.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const format: (map: FixedShapeMap) => string;
+export { resolve as _, QueryAssociation as a, ShapeSelector as c, format as d, formatShape as f, parseTerm as g, parse as h, ParseOptions as i, Start as l, isStart as m, FixedShapeMap as n, QueryShapeMap as o, fromJson as p, NodeSelector as r, ShapeMap_d_exports as s, Association as t, TriplePattern as u, start as v };
+//# sourceMappingURL=ShapeMap-C422pxKl.d.mts.map

package/dist/ShapeMap-CsgKxB2G.mjs

@@ -0,0 +1,181 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { T as blankNode, Y as literal$1, Z as namedNode$1, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { E as match } from "./Dataset-BlmlcI7J.mjs";
+import { i as isAbsolute, l as resolve$1 } from "./Iri-Cr92gsQV.mjs";
+import { n as RdfParseError } from "./Serialization-DP9H5bYQ.mjs";
+import { d as iriRef, i as blankNodeLabel, m as pnChars, p as langTag } from "./Grammar-mQ8CgE1M.mjs";
+import { c as numericLiteral, f as prefixedName, m as stringLiteral, n as booleanLiteral } from "./Grammar-CPlSxGH6.mjs";
+import { n as lexeme, r as skip, t as keyword } from "./tokens-C6BzeodQ.mjs";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Result from "effect/Result";
+import * as Compiler from "@thomasfosterau/effect-parse/Compiler";
+import * as Parser from "@thomasfosterau/effect-parse/Parser";
+import * as Token from "@thomasfosterau/effect-parse/Token";
+// src/shex/ShapeMap.ts
+/**
+* ShapeMaps: associations of nodes with shapes, used both as validation
+* input and output. Supports the ShapeMap compact syntax for fixed maps
+* (`node@shape`, `node@START`) and query maps with triple pattern node
+* selectors (`{FOCUS p _}`, `{_ p FOCUS}`), as well as the JSON form.
+*
+* @since 0.1.0
+*/
+var ShapeMap_exports = /* @__PURE__ */ __exportAll({
+	format: () => format,
+	formatShape: () => formatShape,
+	fromJson: () => fromJson,
+	isStart: () => isStart,
+	parse: () => parse,
+	parseTerm: () => parseTerm,
+	resolve: () => resolve,
+	start: () => start
+});
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const start = { _tag: "Start" };
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isStart = (s) => !Predicate.isString(s);
+/** The options of the current parse, for resolving IRIs. */
+var Options = class extends Context.Service()("@thomasfosterau/effect-rdf/shex/ShapeMap/Options") {};
+const lex = lexeme;
+/**
+* An IRI: an `IRIREF` resolved against the base IRI, or a prefixed name
+* expanded with `prefixes` (falling back to the options' prefixes).
+*/
+const iri = (prefixes) => Parser.alt(Parser.seq(Parser.service(Options), iriRef).pipe(Parser.map(([{ baseIri }, value]) => baseIri === void 0 || isAbsolute(value) ? value : resolve$1(value, baseIri))), Parser.preceded(Parser.peek(prefixedName), Parser.cut(Parser.seq(Parser.service(Options), prefixedName).pipe(Parser.tryMap(([options, { prefix, local }]) => {
+	const ns = Option.orElse(Option.flatMap(prefixes(options), (p) => Option.fromUndefinedOr(p[prefix])), () => Option.fromUndefinedOr(options.prefixes?.[prefix]));
+	return Option.match(ns, {
+		onNone: () => Result.fail(`unknown prefix "${prefix}:"`),
+		onSome: (namespace) => Result.succeed(namespace + local)
+	});
+})))));
+const noPrefixes = () => Option.none();
+const namedNode = iri(noPrefixes).pipe(Parser.map((value) => namedNode$1(value)));
+const literal = Parser.seq(stringLiteral, Parser.opt(Parser.alt(langTag, Parser.preceded(Token.literal("^^"), Parser.cut(lex(namedNode).pipe(Parser.expected("a datatype IRI"))))))).pipe(Parser.map(([value, suffix]) => Option.match(suffix, {
+	onNone: () => literal$1(value),
+	onSome: (s) => literal$1(value, s)
+})));
+const term = lex(Parser.alt(namedNode, blankNodeLabel.pipe(Parser.map((label) => blankNode(label))), literal, numericLiteral.pipe(Parser.map(([value, type]) => literal$1(value, namedNode$1(XSD + type)))), booleanLiteral.pipe(Parser.map((value) => literal$1(value, namedNode$1(`${XSD}boolean`))))));
+const predicate = lex(Parser.alt(Parser.terminated(Token.literal("a"), Parser.not(Token.oneOf([pnChars, ":"]))).pipe(Parser.as(namedNode$1(RDF_TYPE))), namedNode)).pipe(Parser.expected("a predicate"));
+const focus = lex(keyword("FOCUS")).pipe(Parser.as("FOCUS"));
+const wildcard = lex(Parser.terminated(Token.literal("_"), Parser.not(Token.literal(":"))));
+const triplePattern = Parser.preceded(lex(Token.literal("{")), Parser.cut(Parser.terminated(Parser.seq(Parser.alt(focus, wildcard, term.pipe(Parser.filter((t) => !isLiteral(t)), Parser.expected("a subject"))), predicate, Parser.alt(focus, wildcard, term.pipe(Parser.expected("an object")))), lex(Token.literal("}"))).pipe(Parser.tryMap(([subject, verb, object]) => subject === "FOCUS" === (object === "FOCUS") ? Result.fail("a triple pattern needs exactly one FOCUS") : Result.succeed({
+	_tag: "TriplePattern",
+	subject,
+	predicate: verb,
+	object
+})))));
+const nodeSelector = Parser.alt(triplePattern, term).pipe(Parser.expected("a node selector"));
+const shapeSelector = Parser.preceded(lex(Token.literal("@")), Parser.cut(Parser.alt(lex(keyword("START")).pipe(Parser.as(start)), lex(iri((options) => Option.fromUndefinedOr(options.shapePrefixes))), lex(blankNodeLabel).pipe(Parser.map((label) => `_:${label}`))).pipe(Parser.expected("a shape label"))));
+const shapeMap = Compiler.jit(Parser.terminated(Parser.separated(Parser.struct({
+	node: nodeSelector,
+	shape: shapeSelector
+}), lex(Token.literal(","))), skip));
+/**
+* Parses a (query) shape map in the compact syntax.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options = {}) => Effect.suspend(() => {
+	const result = Parser.parse(shapeMap, input, { context: Context.make(Options, options) });
+	if (Result.isSuccess(result)) return Effect.succeed(result.success);
+	const error = result.failure;
+	const { line, column } = error.position;
+	const message = error.cause ?? error.message.slice(error.message.lastIndexOf("\n") + 1);
+	return Effect.fail(new RdfParseError({
+		format: "ShapeMap",
+		message,
+		line,
+		column
+	}));
+});
+const groundTerm = Compiler.jit(Parser.terminated(term, skip));
+/**
+* Parses a single RDF term in N-Triples / Turtle notation (`<iri>`,
+* `_:label`, `"lexical"^^<dt>`, …), as used by the JSON form of shape maps.
+* A bare string that is not a term is taken as an IRI.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parseTerm = (input, options = {}) => {
+	const result = Parser.parse(groundTerm, input, { context: Context.make(Options, options) });
+	if (Result.isSuccess(result)) return result.success;
+	if (input.startsWith("_:")) return blankNode(input.slice(2));
+	return namedNode$1(options.baseIri === void 0 || isAbsolute(input) ? input : resolve$1(input, options.baseIri));
+};
+/**
+* Reads the JSON form of a fixed shape map: an array of
+* `{ "node": term, "shape": label | "START" }` objects. Node terms use
+* N-Triples notation or are bare IRIs.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const fromJson = (json, options = {}) => {
+	if (!Array.isArray(json)) return [];
+	return json.map((entry) => ({
+		node: parseTerm(entry.node, options),
+		shape: entry.shape === "START" ? start : entry.shape.startsWith("_:") || options.baseIri === void 0 || isAbsolute(entry.shape) ? entry.shape : resolve$1(entry.shape, options.baseIri)
+	}));
+};
+/**
+* Resolves a query shape map against a dataset, producing a fixed shape map
+* (duplicates removed, order preserved).
+*
+* @since 0.1.0
+* @category combinators
+*/
+const resolve = (map, dataset) => {
+	const out = [];
+	const seen = MutableHashSet.empty();
+	const push = (node, shape) => {
+		const key = `${node.key} ${isStart(shape) ? "" : shape}`;
+		if (MutableHashSet.has(seen, key)) return;
+		MutableHashSet.add(seen, key);
+		out.push({
+			node,
+			shape
+		});
+	};
+	map.forEach(({ node, shape }) => {
+		if (!Predicate.isTagged(node, "TriplePattern")) return push(node, shape);
+		const pattern = {
+			predicate: node.predicate,
+			subject: node.subject !== "FOCUS" && node.subject !== "_" ? node.subject : void 0,
+			object: node.object !== "FOCUS" && node.object !== "_" ? node.object : void 0
+		};
+		Iterable.forEach(match(dataset, pattern), (q) => push(node.subject === "FOCUS" ? q.subject : q.object, shape));
+	});
+	return out;
+};
+/**
+* Formats a shape selector for display.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatShape = (shape) => isStart(shape) ? "START" : shape.startsWith("_:") ? shape : `<${shape}>`;
+/**
+* Formats a fixed shape map in the compact syntax.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const format = (map) => map.map((a) => `${a.node.key}@${formatShape(a.shape)}`).join(",\n");
+export { isStart as a, resolve as c, fromJson as i, start as l, format as n, parse as o, formatShape as r, parseTerm as s, ShapeMap_exports as t };
+
+//# sourceMappingURL=ShapeMap-CsgKxB2G.mjs.map

package/dist/ShapeMap-CsgKxB2G.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShapeMap-CsgKxB2G.mjs","names":["Tokens.lexeme","TurtleGrammar.iriRef","Iri.isAbsolute","Iri.resolve","TurtleGrammar.prefixedName","Term.namedNode","TurtleGrammar.stringLiteral","TurtleGrammar.langTag","Term.literal","Term.blankNode","TurtleGrammar.pnChars","Tokens.keyword","Term.isLiteral","TurtleGrammar.blankNodeLabel","Tokens.skip","Dataset.match"],"sources":["../src/shex/ShapeMap.ts"],"sourcesContent":["/**\n * ShapeMaps: associations of nodes with shapes, used both as validation\n * input and output. Supports the ShapeMap compact syntax for fixed maps\n * (`node@shape`, `node@START`) and query maps with triple pattern node\n * selectors (`{FOCUS p _}`, `{_ p FOCUS}`), as well as the JSON form.\n *\n * @since 0.1.0\n */\nimport * as Context from 'effect/Context';\nimport * as Iterable from 'effect/Iterable';\nimport * as Effect from 'effect/Effect';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Result from 'effect/Result';\nimport * as Compiler from '@thomasfosterau/effect-parse/Compiler';\nimport * as Parser from '@thomasfosterau/effect-parse/Parser';\nimport * as Token from '@thomasfosterau/effect-parse/Token';\nimport * as Dataset from '../Dataset.ts';\nimport * as Iri from '../Iri.ts';\nimport { RdfParseError } from '../Serialization.ts';\nimport * as Term from '../Term.ts';\nimport * as TurtleGrammar from '../turtle/Grammar.ts';\nimport * as Tokens from './internal/tokens.ts';\nimport * as Predicate from 'effect/Predicate';\n\nconst XSD = 'http://www.w3.org/2001/XMLSchema#';\nconst RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';\n\n/**\n * The `START` shape of a schema.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Start {\n  readonly _tag: 'Start';\n}\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const start: Start = { _tag: 'Start' };\n\n/**\n * A shape label or `START`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type ShapeSelector = string | Start;\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isStart = (s: ShapeSelector): s is Start => !Predicate.isString(s);\n\n/**\n * A triple pattern selecting focus nodes: exactly one of `subject` and\n * `object` is `'FOCUS'`; the other is a term or the wildcard `'_'`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface TriplePattern {\n  readonly _tag: 'TriplePattern';\n  readonly subject: Term.Subject | 'FOCUS' | '_';\n  readonly predicate: Term.NamedNode;\n  readonly object: Term.Object | 'FOCUS' | '_';\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport type NodeSelector = Term.GroundTerm | TriplePattern;\n\n/**\n * An association in a query shape map.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface QueryAssociation {\n  readonly node: NodeSelector;\n  readonly shape: ShapeSelector;\n}\n\n/**\n * An association in a fixed shape map.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Association {\n  readonly node: Term.GroundTerm;\n  readonly shape: ShapeSelector;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport type QueryShapeMap = ReadonlyArray<QueryAssociation>;\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport type FixedShapeMap = ReadonlyArray<Association>;\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ParseOptions {\n  readonly baseIri?: string | undefined;\n  readonly prefixes?: Readonly<Record<string, string>> | undefined;\n  /** Prefixes used only for shape labels (e.g. those of the schema). */\n  readonly shapePrefixes?: Readonly<Record<string, string>> | undefined;\n}\n\n/** The options of the current parse, for resolving IRIs. */\nclass Options extends Context.Service<Options, ParseOptions>()(\n  '@thomasfosterau/effect-rdf/shex/ShapeMap/Options',\n) {}\n\nconst lex = Tokens.lexeme;\n\n/**\n * An IRI: an `IRIREF` resolved against the base IRI, or a prefixed name\n * expanded with `prefixes` (falling back to the options' prefixes).\n */\nconst iri = (\n  prefixes: (options: ParseOptions) => Option.Option<Readonly<Record<string, string>>>,\n): Parser.Parser<string, string, Options> =>\n  Parser.alt(\n    Parser.seq(Parser.service(Options), TurtleGrammar.iriRef).pipe(\n      Parser.map(([{ baseIri }, value]) =>\n        baseIri === undefined || Iri.isAbsolute(value) ? value : Iri.resolve(value, baseIri),\n      ),\n    ),\n    // Once a prefixed name has matched, an unknown prefix is an error.\n    Parser.preceded(\n      Parser.peek(TurtleGrammar.prefixedName),\n      Parser.cut(\n        Parser.seq(Parser.service(Options), TurtleGrammar.prefixedName).pipe(\n          Parser.tryMap(([options, { prefix, local }]) => {\n            const ns = Option.orElse(\n              Option.flatMap(prefixes(options), (p) => Option.fromUndefinedOr(p[prefix])),\n              () => Option.fromUndefinedOr(options.prefixes?.[prefix]),\n            );\n            return Option.match(ns, {\n              onNone: () => Result.fail(`unknown prefix \"${prefix}:\"`),\n              onSome: (namespace) => Result.succeed(namespace + local),\n            });\n          }),\n        ),\n      ),\n    ),\n  );\n\nconst noPrefixes = () => Option.none();\n\nconst namedNode = iri(noPrefixes).pipe(Parser.map((value) => Term.namedNode(value)));\n\nconst literal = Parser.seq(\n  TurtleGrammar.stringLiteral,\n  Parser.opt(\n    Parser.alt(\n      TurtleGrammar.langTag,\n      Parser.preceded(\n        Token.literal('^^'),\n        Parser.cut(lex(namedNode).pipe(Parser.expected('a datatype IRI'))),\n      ),\n    ),\n  ),\n).pipe(\n  Parser.map(([value, suffix]) =>\n    // The suffix is a language tag string or a datatype named node.\n    Option.match(suffix, {\n      onNone: () => Term.literal(value),\n      onSome: (s) => Term.literal(value, s),\n    }),\n  ),\n);\n\nconst term: Parser.Parser<Term.GroundTerm, string, Options> = lex(\n  Parser.alt(\n    namedNode,\n    TurtleGrammar.blankNodeLabel.pipe(Parser.map((label) => Term.blankNode(label))),\n    literal,\n    TurtleGrammar.numericLiteral.pipe(\n      Parser.map(([value, type]) => Term.literal(value, Term.namedNode(XSD + type))),\n    ),\n    TurtleGrammar.booleanLiteral.pipe(\n      Parser.map((value) => Term.literal(value, Term.namedNode(`${XSD}boolean`))),\n    ),\n  ),\n);\n\nconst predicate = lex(\n  Parser.alt(\n    Parser.terminated(\n      Token.literal('a'),\n      Parser.not(Token.oneOf([TurtleGrammar.pnChars, ':'])),\n    ).pipe(Parser.as(Term.namedNode(RDF_TYPE))),\n    namedNode,\n  ),\n).pipe(Parser.expected('a predicate'));\n\nconst focus = lex(Tokens.keyword('FOCUS')).pipe(Parser.as('FOCUS' as const));\nconst wildcard = lex(Parser.terminated(Token.literal('_'), Parser.not(Token.literal(':'))));\n\nconst triplePattern = Parser.preceded(\n  lex(Token.literal('{')),\n  Parser.cut(\n    Parser.terminated(\n      Parser.seq(\n        Parser.alt(\n          focus,\n          wildcard,\n          term.pipe(\n            Parser.filter((t): t is Term.Subject => !Term.isLiteral(t)),\n            Parser.expected('a subject'),\n          ),\n        ),\n        predicate,\n        Parser.alt(focus, wildcard, term.pipe(Parser.expected('an object'))),\n      ),\n      lex(Token.literal('}')),\n    ).pipe(\n      Parser.tryMap(([subject, verb, object]) =>\n        (subject === 'FOCUS') === (object === 'FOCUS')\n          ? Result.fail('a triple pattern needs exactly one FOCUS')\n          : Result.succeed<NodeSelector>({\n              _tag: 'TriplePattern',\n              subject,\n              predicate: verb,\n              object,\n            }),\n      ),\n    ),\n  ),\n);\n\nconst nodeSelector: Parser.Parser<NodeSelector, string, Options> = Parser.alt(\n  triplePattern,\n  term,\n).pipe(Parser.expected('a node selector'));\n\nconst shapeSelector: Parser.Parser<ShapeSelector, string, Options> = Parser.preceded(\n  lex(Token.literal('@')),\n  Parser.cut(\n    Parser.alt(\n      lex(Tokens.keyword('START')).pipe(Parser.as(start)),\n      lex(iri((options) => Option.fromUndefinedOr(options.shapePrefixes))),\n      lex(TurtleGrammar.blankNodeLabel).pipe(Parser.map((label) => `_:${label}`)),\n    ).pipe(Parser.expected('a shape label')),\n  ),\n);\n\nconst shapeMap: Parser.Parser<QueryShapeMap, string, Options> = Compiler.jit(\n  Parser.terminated(\n    Parser.separated(\n      Parser.struct({ node: nodeSelector, shape: shapeSelector }),\n      lex(Token.literal(',')),\n    ),\n    Tokens.skip,\n  ),\n);\n\n/**\n * Parses a (query) shape map in the compact syntax.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parse = (\n  input: string,\n  options: ParseOptions = {},\n): Effect.Effect<QueryShapeMap, RdfParseError> =>\n  Effect.suspend(() => {\n    const result = Parser.parse(shapeMap, input, { context: Context.make(Options, options) });\n    if (Result.isSuccess(result)) return Effect.succeed(result.success);\n    const error = result.failure;\n    const { line, column } = error.position;\n    const message = error.cause ?? error.message.slice(error.message.lastIndexOf('\\n') + 1);\n    return Effect.fail(new RdfParseError({ format: 'ShapeMap', message, line, column }));\n  });\n\n// Compiled once; the options reach `Parser.service(Options)` through the run's\n// context rather than a `provideService` wrapper built per call.\nconst groundTerm = Compiler.jit(Parser.terminated(term, Tokens.skip));\n\n/**\n * Parses a single RDF term in N-Triples / Turtle notation (`<iri>`,\n * `_:label`, `\"lexical\"^^<dt>`, …), as used by the JSON form of shape maps.\n * A bare string that is not a term is taken as an IRI.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parseTerm = (input: string, options: ParseOptions = {}): Term.GroundTerm => {\n  const result = Parser.parse(groundTerm, input, { context: Context.make(Options, options) });\n  if (Result.isSuccess(result)) return result.success;\n  if (input.startsWith('_:')) return Term.blankNode(input.slice(2));\n  return Term.namedNode(\n    options.baseIri === undefined || Iri.isAbsolute(input)\n      ? input\n      : Iri.resolve(input, options.baseIri),\n  );\n};\n\n/**\n * Reads the JSON form of a fixed shape map: an array of\n * `{ \"node\": term, \"shape\": label | \"START\" }` objects. Node terms use\n * N-Triples notation or are bare IRIs.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const fromJson = (json: unknown, options: ParseOptions = {}): FixedShapeMap => {\n  if (!Array.isArray(json)) return [];\n  return json.map((entry: { node: string; shape: string }) => ({\n    node: parseTerm(entry.node, options),\n    shape:\n      entry.shape === 'START'\n        ? start\n        : entry.shape.startsWith('_:') ||\n            options.baseIri === undefined ||\n            Iri.isAbsolute(entry.shape)\n          ? entry.shape\n          : Iri.resolve(entry.shape, options.baseIri),\n  }));\n};\n\n/**\n * Resolves a query shape map against a dataset, producing a fixed shape map\n * (duplicates removed, order preserved).\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const resolve = (map: QueryShapeMap, dataset: Dataset.Dataset): FixedShapeMap => {\n  const out: Array<Association> = [];\n  const seen = MutableHashSet.empty<string>();\n  const push = (node: Term.GroundTerm, shape: ShapeSelector) => {\n    const key = `${node.key} ${isStart(shape) ? '' : shape}`;\n    if (MutableHashSet.has(seen, key)) return;\n    MutableHashSet.add(seen, key);\n    out.push({ node, shape });\n  };\n  map.forEach(({ node, shape }) => {\n    if (!Predicate.isTagged(node, 'TriplePattern')) return push(node, shape);\n    const pattern: Dataset.Pattern = {\n      predicate: node.predicate,\n      subject: node.subject !== 'FOCUS' && node.subject !== '_' ? node.subject : undefined,\n      object: node.object !== 'FOCUS' && node.object !== '_' ? node.object : undefined,\n    };\n    Iterable.forEach(Dataset.match(dataset, pattern), (q) =>\n      push(node.subject === 'FOCUS' ? q.subject : q.object, shape),\n    );\n  });\n  return out;\n};\n\n/**\n * Formats a shape selector for display.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatShape = (shape: ShapeSelector): string =>\n  isStart(shape) ? 'START' : shape.startsWith('_:') ? shape : `<${shape}>`;\n\n/**\n * Formats a fixed shape map in the compact syntax.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const format = (map: FixedShapeMap): string =>\n  map.map((a) => `${a.node.key}@${formatShape(a.shape)}`).join(',\\n');\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAM,MAAM;AACZ,MAAM,WAAW;;;;;AAgBjB,MAAa,QAAe,EAAE,MAAM,QAAQ;;;;;AAc5C,MAAa,WAAW,MAAiC,CAAC,UAAU,SAAS,CAAC;;AAoE9E,IAAM,UAAN,cAAsB,QAAQ,QAA+B,CAAC,CAC5D,kDACF,CAAC,CAAC,CAAC;AAEH,MAAM,MAAMA;;;;;AAMZ,MAAM,OACJ,aAEA,OAAO,IACL,OAAO,IAAI,OAAO,QAAQ,OAAO,GAAGC,MAAoB,CAAC,CAAC,KACxD,OAAO,KAAK,CAAC,EAAE,WAAW,WACxB,YAAY,KAAA,KAAaC,WAAe,KAAK,IAAI,QAAQC,UAAY,OAAO,OAAO,CACrF,CACF,GAEA,OAAO,SACL,OAAO,KAAKC,YAA0B,GACtC,OAAO,IACL,OAAO,IAAI,OAAO,QAAQ,OAAO,GAAGA,YAA0B,CAAC,CAAC,KAC9D,OAAO,QAAQ,CAAC,SAAS,EAAE,QAAQ,aAAa;CAC9C,MAAM,KAAK,OAAO,OAChB,OAAO,QAAQ,SAAS,OAAO,IAAI,MAAM,OAAO,gBAAgB,EAAE,OAAO,CAAC,SACpE,OAAO,gBAAgB,QAAQ,WAAW,OAAO,CACzD;CACA,OAAO,OAAO,MAAM,IAAI;EACtB,cAAc,OAAO,KAAK,mBAAmB,OAAO,GAAG;EACvD,SAAS,cAAc,OAAO,QAAQ,YAAY,KAAK;CACzD,CAAC;AACH,CAAC,CACH,CACF,CACF,CACF;AAEF,MAAM,mBAAmB,OAAO,KAAK;AAErC,MAAM,YAAY,IAAI,UAAU,CAAC,CAAC,KAAK,OAAO,KAAK,UAAUC,YAAe,KAAK,CAAC,CAAC;AAEnF,MAAM,UAAU,OAAO,IACrBC,eACA,OAAO,IACL,OAAO,IACLC,SACA,OAAO,SACL,MAAM,QAAQ,IAAI,GAClB,OAAO,IAAI,IAAI,SAAS,CAAC,CAAC,KAAK,OAAO,SAAS,gBAAgB,CAAC,CAAC,CACnE,CACF,CACF,CACF,CAAC,CAAC,KACA,OAAO,KAAK,CAAC,OAAO,YAElB,OAAO,MAAM,QAAQ;CACnB,cAAcC,UAAa,KAAK;CAChC,SAAS,MAAMA,UAAa,OAAO,CAAC;AACtC,CAAC,CACH,CACF;AAEA,MAAM,OAAwD,IAC5D,OAAO,IACL,WAAA,eAC6B,KAAK,OAAO,KAAK,UAAUC,UAAe,KAAK,CAAC,CAAC,GAC9E,SAAA,eAC6B,KAC3B,OAAO,KAAK,CAAC,OAAO,UAAUD,UAAa,OAAOH,YAAe,MAAM,IAAI,CAAC,CAAC,CAC/E,GAAA,eAC6B,KAC3B,OAAO,KAAK,UAAUG,UAAa,OAAOH,YAAe,GAAG,IAAI,QAAQ,CAAC,CAAC,CAC5E,CACF,CACF;AAEA,MAAM,YAAY,IAChB,OAAO,IACL,OAAO,WACL,MAAM,QAAQ,GAAG,GACjB,OAAO,IAAI,MAAM,MAAM,CAACK,SAAuB,GAAG,CAAC,CAAC,CACtD,CAAC,CAAC,KAAK,OAAO,GAAGL,YAAe,QAAQ,CAAC,CAAC,GAC1C,SACF,CACF,CAAC,CAAC,KAAK,OAAO,SAAS,aAAa,CAAC;AAErC,MAAM,QAAQ,IAAIM,QAAe,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,OAAgB,CAAC;AAC3E,MAAM,WAAW,IAAI,OAAO,WAAW,MAAM,QAAQ,GAAG,GAAG,OAAO,IAAI,MAAM,QAAQ,GAAG,CAAC,CAAC,CAAC;AAE1F,MAAM,gBAAgB,OAAO,SAC3B,IAAI,MAAM,QAAQ,GAAG,CAAC,GACtB,OAAO,IACL,OAAO,WACL,OAAO,IACL,OAAO,IACL,OACA,UACA,KAAK,KACH,OAAO,QAAQ,MAAyB,CAACC,UAAe,CAAC,CAAC,GAC1D,OAAO,SAAS,WAAW,CAC7B,CACF,GACA,WACA,OAAO,IAAI,OAAO,UAAU,KAAK,KAAK,OAAO,SAAS,WAAW,CAAC,CAAC,CACrE,GACA,IAAI,MAAM,QAAQ,GAAG,CAAC,CACxB,CAAC,CAAC,KACA,OAAO,QAAQ,CAAC,SAAS,MAAM,YAC5B,YAAY,aAAc,WAAW,WAClC,OAAO,KAAK,0CAA0C,IACtD,OAAO,QAAsB;CAC3B,MAAM;CACN;CACA,WAAW;CACX;AACF,CAAC,CACP,CACF,CACF,CACF;AAEA,MAAM,eAA6D,OAAO,IACxE,eACA,IACF,CAAC,CAAC,KAAK,OAAO,SAAS,iBAAiB,CAAC;AAEzC,MAAM,gBAA+D,OAAO,SAC1E,IAAI,MAAM,QAAQ,GAAG,CAAC,GACtB,OAAO,IACL,OAAO,IACL,IAAID,QAAe,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,KAAK,CAAC,GAClD,IAAI,KAAK,YAAY,OAAO,gBAAgB,QAAQ,aAAa,CAAC,CAAC,GACnE,IAAIE,cAA4B,CAAC,CAAC,KAAK,OAAO,KAAK,UAAU,KAAK,OAAO,CAAC,CAC5E,CAAC,CAAC,KAAK,OAAO,SAAS,eAAe,CAAC,CACzC,CACF;AAEA,MAAM,WAA0D,SAAS,IACvE,OAAO,WACL,OAAO,UACL,OAAO,OAAO;CAAE,MAAM;CAAc,OAAO;AAAc,CAAC,GAC1D,IAAI,MAAM,QAAQ,GAAG,CAAC,CACxB,GACAC,IACF,CACF;;;;;;;AAQA,MAAa,SACX,OACA,UAAwB,CAAC,MAEzB,OAAO,cAAc;CACnB,MAAM,SAAS,OAAO,MAAM,UAAU,OAAO,EAAE,SAAS,QAAQ,KAAK,SAAS,OAAO,EAAE,CAAC;CACxF,IAAI,OAAO,UAAU,MAAM,GAAG,OAAO,OAAO,QAAQ,OAAO,OAAO;CAClE,MAAM,QAAQ,OAAO;CACrB,MAAM,EAAE,MAAM,WAAW,MAAM;CAC/B,MAAM,UAAU,MAAM,SAAS,MAAM,QAAQ,MAAM,MAAM,QAAQ,YAAY,IAAI,IAAI,CAAC;CACtF,OAAO,OAAO,KAAK,IAAI,cAAc;EAAE,QAAQ;EAAY;EAAS;EAAM;CAAO,CAAC,CAAC;AACrF,CAAC;AAIH,MAAM,aAAa,SAAS,IAAI,OAAO,WAAW,MAAMA,IAAW,CAAC;;;;;;;;;AAUpE,MAAa,aAAa,OAAe,UAAwB,CAAC,MAAuB;CACvF,MAAM,SAAS,OAAO,MAAM,YAAY,OAAO,EAAE,SAAS,QAAQ,KAAK,SAAS,OAAO,EAAE,CAAC;CAC1F,IAAI,OAAO,UAAU,MAAM,GAAG,OAAO,OAAO;CAC5C,IAAI,MAAM,WAAW,IAAI,GAAG,OAAOL,UAAe,MAAM,MAAM,CAAC,CAAC;CAChE,OAAOJ,YACL,QAAQ,YAAY,KAAA,KAAaH,WAAe,KAAK,IACjD,QACAC,UAAY,OAAO,QAAQ,OAAO,CACxC;AACF;;;;;;;;;AAUA,MAAa,YAAY,MAAe,UAAwB,CAAC,MAAqB;CACpF,IAAI,CAAC,MAAM,QAAQ,IAAI,GAAG,OAAO,CAAC;CAClC,OAAO,KAAK,KAAK,WAA4C;EAC3D,MAAM,UAAU,MAAM,MAAM,OAAO;EACnC,OACE,MAAM,UAAU,UACZ,QACA,MAAM,MAAM,WAAW,IAAI,KACzB,QAAQ,YAAY,KAAA,KACpBD,WAAe,MAAM,KAAK,IAC1B,MAAM,QACNC,UAAY,MAAM,OAAO,QAAQ,OAAO;CAClD,EAAE;AACJ;;;;;;;;AASA,MAAa,WAAW,KAAoB,YAA4C;CACtF,MAAM,MAA0B,CAAC;CACjC,MAAM,OAAO,eAAe,MAAc;CAC1C,MAAM,QAAQ,MAAuB,UAAyB;EAC5D,MAAM,MAAM,GAAG,KAAK,IAAI,GAAG,QAAQ,KAAK,IAAI,KAAK;EACjD,IAAI,eAAe,IAAI,MAAM,GAAG,GAAG;EACnC,eAAe,IAAI,MAAM,GAAG;EAC5B,IAAI,KAAK;GAAE;GAAM;EAAM,CAAC;CAC1B;CACA,IAAI,SAAS,EAAE,MAAM,YAAY;EAC/B,IAAI,CAAC,UAAU,SAAS,MAAM,eAAe,GAAG,OAAO,KAAK,MAAM,KAAK;EACvE,MAAM,UAA2B;GAC/B,WAAW,KAAK;GAChB,SAAS,KAAK,YAAY,WAAW,KAAK,YAAY,MAAM,KAAK,UAAU,KAAA;GAC3E,QAAQ,KAAK,WAAW,WAAW,KAAK,WAAW,MAAM,KAAK,SAAS,KAAA;EACzE;EACA,SAAS,QAAQY,MAAc,SAAS,OAAO,IAAI,MACjD,KAAK,KAAK,YAAY,UAAU,EAAE,UAAU,EAAE,QAAQ,KAAK,CAC7D;CACF,CAAC;CACD,OAAO;AACT;;;;;;;AAQA,MAAa,eAAe,UAC1B,QAAQ,KAAK,IAAI,UAAU,MAAM,WAAW,IAAI,IAAI,QAAQ,IAAI,MAAM;;;;;;;AAQxE,MAAa,UAAU,QACrB,IAAI,KAAK,MAAM,GAAG,EAAE,KAAK,IAAI,GAAG,YAAY,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,KAAK"}