@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Iri-BB8Ks-BF.d.mts

@@ -0,0 +1,84 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+declare namespace Iri_d_exports {
+  export { IriReferenceSchema, IriSchema, isAbsolute, isValid, isValidReference, relativize, removeDotSegments, resolve, withoutFragment };
+}
+/**
+ * Removes `.` and `..` segments from a path (RFC 3986 §5.2.4).
+ *
+ * @since 0.1.0
+ */
+declare const removeDotSegments: (path: string) => string;
+/**
+ * Whether a string is an absolute IRI (has a scheme).
+ *
+ * @since 0.1.0
+ */
+declare const isAbsolute: (iri: string) => boolean;
+/**
+ * Resolves a (possibly relative) IRI reference against a base IRI, following
+ * RFC 3986 §5.2.
+ *
+ * @since 0.1.0
+ */
+declare const resolve: (reference: string, base: string | undefined) => string;
+/**
+ * Removes the fragment from an IRI.
+ *
+ * @since 0.1.0
+ */
+declare const withoutFragment: (iri: string) => string;
+/**
+ * Computes a relative reference for `iri` with respect to `base`, if a
+ * simple one exists (same scheme and authority). Resolving the result against
+ * `base` always yields `iri`.
+ *
+ * @since 0.1.0
+ */
+declare const relativize: (iri: string, base: string) => Option.Option<string>;
+/**
+ * Whether a string is a syntactically valid absolute IRI (RFC 3987).
+ *
+ * @since 0.1.0
+ */
+declare const isValid: (iri: string) => boolean;
+/**
+ * Whether a string is a syntactically valid IRI reference (RFC 3987): an
+ * absolute IRI, or a relative reference whose first path segment has no `:`.
+ *
+ * @since 0.1.0
+ */
+declare const isValidReference: (reference: string) => boolean;
+/**
+ * Schema of an absolute IRI (`isValid`): a string, with JSON Schema
+ * `format: "iri"`. Use it to validate IRIs from `Config`, CLI flags or HTTP
+ * parameters.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const IriSchema: Schema.String;
+/**
+ * The type `IriSchema` decodes to: a string.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type IriSchema = typeof IriSchema.Type;
+/**
+ * Schema of an IRI reference, absolute or relative (`isValidReference`): a
+ * string, with JSON Schema `format: "iri-reference"`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const IriReferenceSchema: Schema.String;
+/**
+ * The type `IriReferenceSchema` decodes to: a string.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type IriReferenceSchema = typeof IriReferenceSchema.Type;
+export { isValid as a, removeDotSegments as c, isAbsolute as i, resolve as l, IriSchema as n, isValidReference as o, Iri_d_exports as r, relativize as s, IriReferenceSchema as t, withoutFragment as u };
+//# sourceMappingURL=Iri-BB8Ks-BF.d.mts.map

package/dist/Iri-Cr92gsQV.mjs

@@ -0,0 +1,232 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { t as loop } from "./loop-DZ2hXlr_.mjs";
+import * as Equal from "effect/Equal";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Str from "effect/String";
+// src/Iri.ts
+/**
+* IRI utilities: RFC 3986 reference resolution, relativisation and
+* validation.
+*
+* @since 0.1.0
+*/
+var Iri_exports = /* @__PURE__ */ __exportAll({
+	IriReferenceSchema: () => IriReferenceSchema,
+	IriSchema: () => IriSchema,
+	isAbsolute: () => isAbsolute,
+	isValid: () => isValid,
+	isValidReference: () => isValidReference,
+	relativize: () => relativize,
+	removeDotSegments: () => removeDotSegments,
+	resolve: () => resolve,
+	withoutFragment: () => withoutFragment
+});
+const PARTS = /^(?:([A-Za-z][A-Za-z0-9+.-]*):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/s;
+const parse = (iri) => {
+	const m = PARTS.exec(iri) ?? [];
+	return {
+		scheme: Option.fromUndefinedOr(m[1]),
+		authority: Option.fromUndefinedOr(m[2]),
+		path: m[3] ?? "",
+		query: Option.fromUndefinedOr(m[4]),
+		fragment: Option.fromUndefinedOr(m[5])
+	};
+};
+let lastBase = "";
+let lastBaseParts = parse("");
+const parseBase = (base) => {
+	if (base !== lastBase) {
+		lastBaseParts = parse(base);
+		lastBase = base;
+	}
+	return lastBaseParts;
+};
+/** `part` between `before` and `after`, or nothing when it is absent. */
+const affix = (part, before, after) => Option.match(part, {
+	onNone: () => "",
+	onSome: (v) => `${before}${v}${after}`
+});
+const recompose = (p) => affix(p.scheme, "", ":") + affix(p.authority, "//", "") + p.path + affix(p.query, "?", "") + affix(p.fragment, "#", "");
+const DOT_SEGMENT = /(?:^|\/)\.\.?(?:\/|$)/;
+/**
+* Removes `.` and `..` segments from a path (RFC 3986 §5.2.4).
+*
+* @since 0.1.0
+*/
+const removeDotSegments = (path) => {
+	if (!DOT_SEGMENT.test(path)) return path;
+	let input = path;
+	const output = [];
+	loop(() => {
+		if (!Str.isNonEmpty(input)) return false;
+		if (input.startsWith("../")) input = input.slice(3);
+		else if (input.startsWith("./")) input = input.slice(2);
+		else if (input.startsWith("/./")) input = input.slice(2);
+		else if (input === "/.") input = "/";
+		else if (input.startsWith("/../")) {
+			input = input.slice(3);
+			output.pop();
+		} else if (input === "/..") {
+			input = "/";
+			output.pop();
+		} else if (input === "." || input === "..") input = "";
+		else {
+			const start = input.startsWith("/") ? 1 : 0;
+			const next = input.indexOf("/", start);
+			const segment = next === -1 ? input : input.slice(0, next);
+			output.push(segment);
+			input = next === -1 ? "" : input.slice(next);
+		}
+		return true;
+	});
+	return output.join("");
+};
+const merge = (base, ref) => {
+	if (Option.isSome(base.authority) && base.path === "") return `/${ref}`;
+	const i = base.path.lastIndexOf("/");
+	return i === -1 ? ref : base.path.slice(0, i + 1) + ref;
+};
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+/**
+* Whether a string is an absolute IRI (has a scheme).
+*
+* @since 0.1.0
+*/
+const isAbsolute = (iri) => SCHEME.test(iri);
+const SCHEME_THEN_PATH = /^[A-Za-z][A-Za-z0-9+.-]*:(?!\.)/;
+/**
+* Whether `iri` has a scheme and no `.` or `..` segment anywhere, without
+* splitting it into its parts: such a reference resolves to itself
+* (RFC 3986 §5.2.2), and most references in a document are like that. A
+* `/.` anywhere (even in the query or fragment) or a path starting with `.`
+* sends the reference down the full algorithm.
+*/
+const isPlainAbsolute = (iri) => SCHEME_THEN_PATH.test(iri) && !iri.includes("/.");
+/**
+* Resolves a (possibly relative) IRI reference against a base IRI, following
+* RFC 3986 §5.2.
+*
+* @since 0.1.0
+*/
+const resolve = (reference, base) => {
+	if (base === void 0 || base === "") return reference;
+	if (isPlainAbsolute(reference)) return reference;
+	const r = parse(reference);
+	if (Option.isSome(r.scheme) && !DOT_SEGMENT.test(r.path)) return reference;
+	const b = parseBase(base);
+	const fragment = r.fragment;
+	const t = Option.isSome(r.scheme) ? {
+		scheme: r.scheme,
+		authority: r.authority,
+		path: removeDotSegments(r.path),
+		query: r.query,
+		fragment
+	} : Option.isSome(r.authority) ? {
+		scheme: b.scheme,
+		authority: r.authority,
+		path: removeDotSegments(r.path),
+		query: r.query,
+		fragment
+	} : r.path === "" ? {
+		scheme: b.scheme,
+		authority: b.authority,
+		path: b.path,
+		query: Option.orElse(r.query, () => b.query),
+		fragment
+	} : {
+		scheme: b.scheme,
+		authority: b.authority,
+		path: r.path.startsWith("/") ? removeDotSegments(r.path) : removeDotSegments(merge(b, r.path)),
+		query: r.query,
+		fragment
+	};
+	return recompose(t);
+};
+/**
+* Removes the fragment from an IRI.
+*
+* @since 0.1.0
+*/
+const withoutFragment = (iri) => {
+	const i = iri.indexOf("#");
+	return i === -1 ? iri : iri.slice(0, i);
+};
+/**
+* Computes a relative reference for `iri` with respect to `base`, if a
+* simple one exists (same scheme and authority). Resolving the result against
+* `base` always yields `iri`.
+*
+* @since 0.1.0
+*/
+const relativize = (iri, base) => {
+	if (iri === base) return Option.some("");
+	const i = parse(iri);
+	const b = parse(base);
+	if (!Equal.equals(i.scheme, b.scheme) || !Equal.equals(i.authority, b.authority) || Option.isNone(i.scheme)) return Option.none();
+	const relative = (path) => recompose({
+		scheme: Option.none(),
+		authority: Option.none(),
+		path,
+		query: i.query,
+		fragment: i.fragment
+	});
+	const dir = b.path.slice(0, b.path.lastIndexOf("/") + 1);
+	const rest = i.path.slice(dir.length);
+	const candidate = i.path === b.path ? Equal.equals(i.query, b.query) ? Option.map(i.fragment, (f) => `#${f}`) : Option.isSome(i.query) ? Option.some(relative("")) : Option.none() : Option.orElse(dir !== "" && i.path.startsWith(dir) && rest !== "" && !/^[^/]*:/.test(rest) ? Option.some(relative(rest)) : Option.none(), () => i.path.startsWith("/") && !i.path.startsWith("//") ? Option.some(relative(i.path)) : Option.none());
+	return Option.filter(candidate, (c) => resolve(c, base) === iri);
+};
+const UCSCHAR = "\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF\\u{10000}-\\u{1FFFD}\\u{20000}-\\u{2FFFD}\\u{30000}-\\u{3FFFD}\\u{40000}-\\u{4FFFD}\\u{50000}-\\u{5FFFD}\\u{60000}-\\u{6FFFD}\\u{70000}-\\u{7FFFD}\\u{80000}-\\u{8FFFD}\\u{90000}-\\u{9FFFD}\\u{A0000}-\\u{AFFFD}\\u{B0000}-\\u{BFFFD}\\u{C0000}-\\u{CFFFD}\\u{D0000}-\\u{DFFFD}\\u{E1000}-\\u{EFFFD}";
+const IPRIVATE = "\\uE000-\\uF8FF\\u{F0000}-\\u{FFFFD}\\u{100000}-\\u{10FFFD}";
+const IUNRESERVED = `A-Za-z0-9\\-._~${UCSCHAR}`;
+const SUBDELIMS = "!$&'()*+,;=";
+const PCT = "%[0-9A-Fa-f]{2}";
+const IPCHAR = `(?:[${IUNRESERVED}${SUBDELIMS}:@]|${PCT})`;
+const IRI_AFTER_SCHEME = `(?://(?:(?:[${IUNRESERVED}${SUBDELIMS}:]|${PCT})*@)?(?:\\[[0-9A-Fa-f:.vV${IUNRESERVED}${SUBDELIMS}]*\\]|(?:[${IUNRESERVED}${SUBDELIMS}]|${PCT})*)(?::[0-9]*)?)?(?:/?${IPCHAR}*)*(?:\\?(?:${IPCHAR}|[/?${IPRIVATE}])*)?(?:#(?:${IPCHAR}|[/?])*)?`;
+const IRI_RE = new RegExp(`^[A-Za-z][A-Za-z0-9+.\\-]*:${IRI_AFTER_SCHEME}$`, "u");
+/**
+* Whether a string is a syntactically valid absolute IRI (RFC 3987).
+*
+* @since 0.1.0
+*/
+const isValid = (iri) => IRI_RE.test(iri);
+const RELATIVE_RE = new RegExp(`^${IRI_AFTER_SCHEME}$`, "u");
+/**
+* Whether a string is a syntactically valid IRI reference (RFC 3987): an
+* absolute IRI, or a relative reference whose first path segment has no `:`.
+*
+* @since 0.1.0
+*/
+const isValidReference = (reference) => isAbsolute(reference) ? isValid(reference) : !/^[^/?#]*:/.test(reference) && RELATIVE_RE.test(reference);
+/**
+* Schema of an absolute IRI (`isValid`): a string, with JSON Schema
+* `format: "iri"`. Use it to validate IRIs from `Config`, CLI flags or HTTP
+* parameters.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const IriSchema = Schema.String.check(Schema.makeFilter((s) => isValid(s), {
+	identifier: "isIri",
+	title: "IRI",
+	description: "An absolute IRI (RFC 3987).",
+	expected: "an absolute IRI",
+	toJsonSchema: () => ({ format: "iri" })
+})).annotate({ identifier: "Iri" });
+/**
+* Schema of an IRI reference, absolute or relative (`isValidReference`): a
+* string, with JSON Schema `format: "iri-reference"`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const IriReferenceSchema = Schema.String.check(Schema.makeFilter((s) => isValidReference(s), {
+	identifier: "isIriReference",
+	title: "IRI reference",
+	description: "An absolute IRI or relative reference (RFC 3987).",
+	expected: "an IRI reference",
+	toJsonSchema: () => ({ format: "iri-reference" })
+})).annotate({ identifier: "IriReference" });
+export { isValid as a, removeDotSegments as c, isAbsolute as i, resolve as l, IriSchema as n, isValidReference as o, Iri_exports as r, relativize as s, IriReferenceSchema as t, withoutFragment as u };
+
+//# sourceMappingURL=Iri-Cr92gsQV.mjs.map

package/dist/Iri-Cr92gsQV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Iri-Cr92gsQV.mjs","names":[],"sources":["../src/Iri.ts"],"sourcesContent":["/**\n * IRI utilities: RFC 3986 reference resolution, relativisation and\n * validation.\n *\n * @since 0.1.0\n */\nimport * as Equal from 'effect/Equal';\nimport * as Str from 'effect/String';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport { loop } from './internal/loop.ts';\n\ninterface Parts {\n  readonly scheme: Option.Option<string>;\n  readonly authority: Option.Option<string>;\n  readonly path: string;\n  readonly query: Option.Option<string>;\n  readonly fragment: Option.Option<string>;\n}\n\nconst PARTS =\n  /^(?:([A-Za-z][A-Za-z0-9+.-]*):)?(?:\\/\\/([^/?#]*))?([^?#]*)(?:\\?([^#]*))?(?:#(.*))?$/s;\n\nconst parse = (iri: string): Parts => {\n  // Every part of the pattern is optional, so it matches any string\n  const m = PARTS.exec(iri) ?? [];\n  return {\n    scheme: Option.fromUndefinedOr(m[1]),\n    authority: Option.fromUndefinedOr(m[2]),\n    path: m[3] ?? '',\n    query: Option.fromUndefinedOr(m[4]),\n    fragment: Option.fromUndefinedOr(m[5]),\n  };\n};\n\n// A document resolves many references against one base, so the last base's\n// parts are kept. `Parts` are never mutated once parsed.\nlet lastBase = '';\nlet lastBaseParts: Parts = parse('');\n\nconst parseBase = (base: string): Parts => {\n  if (base !== lastBase) {\n    lastBaseParts = parse(base);\n    lastBase = base;\n  }\n  return lastBaseParts;\n};\n\n/** `part` between `before` and `after`, or nothing when it is absent. */\nconst affix = (part: Option.Option<string>, before: string, after: string): string =>\n  Option.match(part, { onNone: () => '', onSome: (v) => `${before}${v}${after}` });\n\nconst recompose = (p: Parts): string =>\n  affix(p.scheme, '', ':') +\n  affix(p.authority, '//', '') +\n  p.path +\n  affix(p.query, '?', '') +\n  affix(p.fragment, '#', '');\n\n// A `.` or `..` segment: the only thing `removeDotSegments` changes.\nconst DOT_SEGMENT = /(?:^|\\/)\\.\\.?(?:\\/|$)/;\n\n/**\n * Removes `.` and `..` segments from a path (RFC 3986 §5.2.4).\n *\n * @since 0.1.0\n */\nexport const removeDotSegments = (path: string): string => {\n  // Most paths have no dot segment, and the algorithm leaves those unchanged.\n  if (!DOT_SEGMENT.test(path)) return path;\n  let input = path;\n  const output: Array<string> = [];\n  loop(() => {\n    if (!Str.isNonEmpty(input)) return false;\n    if (input.startsWith('../')) input = input.slice(3);\n    else if (input.startsWith('./')) input = input.slice(2);\n    else if (input.startsWith('/./')) input = input.slice(2);\n    else if (input === '/.') input = '/';\n    else if (input.startsWith('/../')) {\n      input = input.slice(3);\n      output.pop();\n    } else if (input === '/..') {\n      input = '/';\n      output.pop();\n    } else if (input === '.' || input === '..') input = '';\n    else {\n      const start = input.startsWith('/') ? 1 : 0;\n      const next = input.indexOf('/', start);\n      const segment = next === -1 ? input : input.slice(0, next);\n      output.push(segment);\n      input = next === -1 ? '' : input.slice(next);\n    }\n    return true;\n  });\n  return output.join('');\n};\n\nconst merge = (base: Parts, ref: string): string => {\n  if (Option.isSome(base.authority) && base.path === '') return `/${ref}`;\n  const i = base.path.lastIndexOf('/');\n  return i === -1 ? ref : base.path.slice(0, i + 1) + ref;\n};\n\n// Hoisted: a regex literal makes a new `RegExp` each time it is evaluated.\nconst SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;\n\n/**\n * Whether a string is an absolute IRI (has a scheme).\n *\n * @since 0.1.0\n */\nexport const isAbsolute = (iri: string): boolean => SCHEME.test(iri);\n\nconst SCHEME_THEN_PATH = /^[A-Za-z][A-Za-z0-9+.-]*:(?!\\.)/;\n\n/**\n * Whether `iri` has a scheme and no `.` or `..` segment anywhere, without\n * splitting it into its parts: such a reference resolves to itself\n * (RFC 3986 §5.2.2), and most references in a document are like that. A\n * `/.` anywhere (even in the query or fragment) or a path starting with `.`\n * sends the reference down the full algorithm.\n */\nconst isPlainAbsolute = (iri: string): boolean => SCHEME_THEN_PATH.test(iri) && !iri.includes('/.');\n\n/**\n * Resolves a (possibly relative) IRI reference against a base IRI, following\n * RFC 3986 §5.2.\n *\n * @since 0.1.0\n */\nexport const resolve = (reference: string, base: string | undefined): string => {\n  if (base === undefined || base === '') return reference;\n  if (isPlainAbsolute(reference)) return reference;\n  const r = parse(reference);\n  // An absolute reference without dot segments resolves to itself (§5.2.2:\n  // only its path is rewritten, by `removeDotSegments`).\n  if (Option.isSome(r.scheme) && !DOT_SEGMENT.test(r.path)) return reference;\n  const b = parseBase(base);\n  const fragment = r.fragment;\n  const t: Parts = Option.isSome(r.scheme)\n    ? {\n        scheme: r.scheme,\n        authority: r.authority,\n        path: removeDotSegments(r.path),\n        query: r.query,\n        fragment,\n      }\n    : Option.isSome(r.authority)\n      ? {\n          scheme: b.scheme,\n          authority: r.authority,\n          path: removeDotSegments(r.path),\n          query: r.query,\n          fragment,\n        }\n      : r.path === ''\n        ? {\n            scheme: b.scheme,\n            authority: b.authority,\n            path: b.path,\n            query: Option.orElse(r.query, () => b.query),\n            fragment,\n          }\n        : {\n            scheme: b.scheme,\n            authority: b.authority,\n            path: r.path.startsWith('/')\n              ? removeDotSegments(r.path)\n              : removeDotSegments(merge(b, r.path)),\n            query: r.query,\n            fragment,\n          };\n  return recompose(t);\n};\n\n/**\n * Removes the fragment from an IRI.\n *\n * @since 0.1.0\n */\nexport const withoutFragment = (iri: string): string => {\n  const i = iri.indexOf('#');\n  return i === -1 ? iri : iri.slice(0, i);\n};\n\n/**\n * Computes a relative reference for `iri` with respect to `base`, if a\n * simple one exists (same scheme and authority). Resolving the result against\n * `base` always yields `iri`.\n *\n * @since 0.1.0\n */\nexport const relativize = (iri: string, base: string): Option.Option<string> => {\n  if (iri === base) return Option.some('');\n  const i = parse(iri);\n  const b = parse(base);\n  if (\n    !Equal.equals(i.scheme, b.scheme) ||\n    !Equal.equals(i.authority, b.authority) ||\n    Option.isNone(i.scheme)\n  ) {\n    return Option.none();\n  }\n  // `iri` as a reference with only `path` and its query and fragment\n  const relative = (path: string): string =>\n    recompose({\n      scheme: Option.none(),\n      authority: Option.none(),\n      path,\n      query: i.query,\n      fragment: i.fragment,\n    });\n  const dir = b.path.slice(0, b.path.lastIndexOf('/') + 1);\n  const rest = i.path.slice(dir.length);\n  const candidate: Option.Option<string> =\n    i.path === b.path\n      ? Equal.equals(i.query, b.query)\n        ? Option.map(i.fragment, (f) => `#${f}`)\n        : Option.isSome(i.query)\n          ? Option.some(relative(''))\n          : Option.none()\n      : Option.orElse(\n          // Avoid references whose first segment looks like a scheme.\n          dir !== '' && i.path.startsWith(dir) && rest !== '' && !/^[^/]*:/.test(rest)\n            ? Option.some(relative(rest))\n            : Option.none(),\n          () =>\n            i.path.startsWith('/') && !i.path.startsWith('//')\n              ? Option.some(relative(i.path))\n              : Option.none(),\n        );\n  return Option.filter(candidate, (c) => resolve(c, base) === iri);\n};\n\n// IRI grammar (RFC 3987) character classes, used for validation.\nconst UCSCHAR =\n  '\\\\u00A0-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFEF\\\\u{10000}-\\\\u{1FFFD}\\\\u{20000}-\\\\u{2FFFD}\\\\u{30000}-\\\\u{3FFFD}\\\\u{40000}-\\\\u{4FFFD}\\\\u{50000}-\\\\u{5FFFD}\\\\u{60000}-\\\\u{6FFFD}\\\\u{70000}-\\\\u{7FFFD}\\\\u{80000}-\\\\u{8FFFD}\\\\u{90000}-\\\\u{9FFFD}\\\\u{A0000}-\\\\u{AFFFD}\\\\u{B0000}-\\\\u{BFFFD}\\\\u{C0000}-\\\\u{CFFFD}\\\\u{D0000}-\\\\u{DFFFD}\\\\u{E1000}-\\\\u{EFFFD}';\nconst IPRIVATE = '\\\\uE000-\\\\uF8FF\\\\u{F0000}-\\\\u{FFFFD}\\\\u{100000}-\\\\u{10FFFD}';\nconst IUNRESERVED = `A-Za-z0-9\\\\-._~${UCSCHAR}`;\nconst SUBDELIMS = \"!$&'()*+,;=\";\nconst PCT = '%[0-9A-Fa-f]{2}';\nconst IPCHAR = `(?:[${IUNRESERVED}${SUBDELIMS}:@]|${PCT})`;\n// `ihier-part` / `irelative-part` (optional authority, then a path), query and fragment: the\n// IRI grammar after the scheme, shared by absolute IRIs and relative references.\nconst IRI_AFTER_SCHEME =\n  `(?://(?:(?:[${IUNRESERVED}${SUBDELIMS}:]|${PCT})*@)?(?:\\\\[[0-9A-Fa-f:.vV${IUNRESERVED}${SUBDELIMS}]*\\\\]|(?:[${IUNRESERVED}${SUBDELIMS}]|${PCT})*)(?::[0-9]*)?)?` +\n  `(?:/?${IPCHAR}*)*` +\n  `(?:\\\\?(?:${IPCHAR}|[/?${IPRIVATE}])*)?` +\n  `(?:#(?:${IPCHAR}|[/?])*)?`;\nconst IRI_RE = new RegExp(`^[A-Za-z][A-Za-z0-9+.\\\\-]*:${IRI_AFTER_SCHEME}$`, 'u');\n\n/**\n * Whether a string is a syntactically valid absolute IRI (RFC 3987).\n *\n * @since 0.1.0\n */\nexport const isValid = (iri: string): boolean => IRI_RE.test(iri);\n\n// A relative reference (RFC 3987 `irelative-ref`): the IRI grammar without the scheme.\nconst RELATIVE_RE = new RegExp(`^${IRI_AFTER_SCHEME}$`, 'u');\n\n/**\n * Whether a string is a syntactically valid IRI reference (RFC 3987): an\n * absolute IRI, or a relative reference whose first path segment has no `:`.\n *\n * @since 0.1.0\n */\nexport const isValidReference = (reference: string): boolean =>\n  isAbsolute(reference)\n    ? isValid(reference)\n    : !/^[^/?#]*:/.test(reference) && RELATIVE_RE.test(reference);\n\n/**\n * Schema of an absolute IRI (`isValid`): a string, with JSON Schema\n * `format: \"iri\"`. Use it to validate IRIs from `Config`, CLI flags or HTTP\n * parameters.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const IriSchema: Schema.String = Schema.String.check(\n  Schema.makeFilter((s: string) => isValid(s), {\n    identifier: 'isIri',\n    title: 'IRI',\n    description: 'An absolute IRI (RFC 3987).',\n    expected: 'an absolute IRI',\n    toJsonSchema: () => ({ format: 'iri' }),\n  }),\n).annotate({ identifier: 'Iri' });\n\n/**\n * The type `IriSchema` decodes to: a string.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type IriSchema = typeof IriSchema.Type;\n\n/**\n * Schema of an IRI reference, absolute or relative (`isValidReference`): a\n * string, with JSON Schema `format: \"iri-reference\"`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const IriReferenceSchema: Schema.String = Schema.String.check(\n  Schema.makeFilter((s: string) => isValidReference(s), {\n    identifier: 'isIriReference',\n    title: 'IRI reference',\n    description: 'An absolute IRI or relative reference (RFC 3987).',\n    expected: 'an IRI reference',\n    toJsonSchema: () => ({ format: 'iri-reference' }),\n  }),\n).annotate({ identifier: 'IriReference' });\n\n/**\n * The type `IriReferenceSchema` decodes to: a string.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type IriReferenceSchema = typeof IriReferenceSchema.Type;\n"],"mappings":"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"}

package/dist/Iri.d.mts

@@ -0,0 +1,2 @@
+import { a as isValid, c as removeDotSegments, i as isAbsolute, l as resolve, n as IriSchema, o as isValidReference, s as relativize, t as IriReferenceSchema, u as withoutFragment } from "./Iri-BB8Ks-BF.mjs";
+export { IriReferenceSchema, IriSchema, isAbsolute, isValid, isValidReference, relativize, removeDotSegments, resolve, withoutFragment };

package/dist/Iri.mjs

@@ -0,0 +1 @@
+export { t as IriReferenceSchema, n as IriSchema, i as isAbsolute, a as isValid, o as isValidReference, s as relativize, c as removeDotSegments, l as resolve, u as withoutFragment } from "./Iri-Cr92gsQV.mjs";

package/dist/Isomorphism-B6qTY-xy.d.mts

@@ -0,0 +1,28 @@
+import { i as Formula } from "./Model-DaMmxurZ.mjs";
+import * as Option from "effect/Option";
+declare namespace Isomorphism_d_exports {
+  export { bijection, isomorphic };
+}
+/**
+ * Finds a renaming of blank nodes and variables from `self` to `that` under
+ * which the two formulas are equal. Keys of the returned map are
+ * `_:label` / `?name` of `self`, values those of `that` (nodes generated for
+ * collections and nested formulas are omitted).
+ *
+ * @since 0.1.0
+ * @category isomorphism
+ */
+declare const bijection: (self: Formula, that: Formula) => Option.Option<ReadonlyMap<string, string>>;
+/**
+ * Whether two formulas are isomorphic: equal up to a consistent renaming of
+ * blank nodes and variables, recursively through nested formulas.
+ *
+ * @since 0.1.0
+ * @category isomorphism
+ */
+declare const isomorphic: {
+  (that: Formula): (self: Formula) => boolean;
+  (self: Formula, that: Formula): boolean;
+};
+export { bijection as n, isomorphic as r, Isomorphism_d_exports as t };
+//# sourceMappingURL=Isomorphism-B6qTY-xy.d.mts.map

package/dist/Isomorphism-BmqxhKyJ.mjs

@@ -0,0 +1,232 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { K as isTriple, M as hasBlankNodes, N as isBlankNode, X as mapTerms, t as BlankNode } from "./Term-CFLG1qu4.mjs";
+import { t as loop } from "./loop-DZ2hXlr_.mjs";
+import { T as map, v as has } from "./Dataset-BlmlcI7J.mjs";
+import * as Arr from "effect/Array";
+import { dual } from "effect/Function";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Order from "effect/Order";
+// src/Isomorphism.ts
+/**
+* Blank-node-aware dataset comparison (RDF graph isomorphism).
+*
+* Uses iterative signature refinement to partition blank nodes, then a
+* backtracking search over the (usually tiny) ambiguous classes.
+*
+* @since 0.1.0
+*/
+var Isomorphism_exports = /* @__PURE__ */ __exportAll({
+	bijection: () => bijection,
+	isomorphic: () => isomorphic,
+	relabel: () => relabel
+});
+const fnv = (s) => {
+	let h1 = 2166136261;
+	let h2 = 16777619;
+	loop((i) => {
+		if (i >= s.length) return false;
+		const c = s.charCodeAt(i);
+		h1 = Math.imul(h1 ^ c, 16777619);
+		h2 = Math.imul(h2 ^ c, 1540483477);
+		return true;
+	});
+	return (h1 >>> 0).toString(36) + (h2 >>> 0).toString(36);
+};
+/** Appends the blank nodes of `t` (and of the triple terms inside it) to `out`, each once. */
+const collectBlankNodes = (t, out) => {
+	if (isBlankNode(t)) {
+		if (!out.includes(t.value)) out.push(t.value);
+	} else if (isTriple(t)) {
+		collectBlankNodes(t.subject, out);
+		collectBlankNodes(t.object, out);
+	}
+};
+/** The distinct blank nodes of a quad, in order of first occurrence. */
+const quadBlankNodes = (q) => {
+	const out = [];
+	collectBlankNodes(q.subject, out);
+	collectBlankNodes(q.object, out);
+	collectBlankNodes(q.graph, out);
+	return out;
+};
+const labelOf = (labels, node) => Option.getOrElse(MutableHashMap.get(labels, node), () => "");
+const compile = (t, self, index, out) => {
+	if (isBlankNode(t)) {
+		if (t.value === self) out.push("@self");
+		else out.push(Option.getOrElse(MutableHashMap.get(index, t.value), () => "@"));
+	} else if (isTriple(t)) {
+		out.push("<<");
+		compile(t.subject, self, index, out);
+		out.push(` ${t.predicate.key} `);
+		compile(t.object, self, index, out);
+		out.push(">>");
+	} else out.push(t.key);
+};
+const template = (q, self, index) => {
+	const out = [];
+	compile(q.subject, self, index, out);
+	out.push(` ${q.predicate.key} `);
+	compile(q.object, self, index, out);
+	out.push(" ");
+	compile(q.graph, self, index, out);
+	return out;
+};
+/** A template with the blank nodes' labels filled in. */
+const render = (t, labels) => t.map((part) => Predicate.isString(part) ? part : `@${labels[part] ?? ""}`).join("");
+/** The quads a blank node occurs in. */
+const quadsOf = (p, node) => Option.getOrElse(MutableHashMap.get(p.byNode, node), () => []);
+const refine = (quads) => {
+	const byNode = MutableHashMap.empty();
+	quads.forEach((q) => {
+		quadBlankNodes(q).forEach((b) => {
+			const list = MutableHashMap.get(byNode, b);
+			if (Option.isSome(list)) list.value.push(q);
+			else MutableHashMap.set(byNode, b, [q]);
+		});
+	});
+	const nodes = Arr.fromIterable(MutableHashMap.keys(byNode));
+	const index = MutableHashMap.fromIterable(nodes.map((n, i) => [n, i]));
+	const templates = nodes.map((n) => Option.getOrElse(MutableHashMap.get(byNode, n), () => []).map((q) => template(q, n, index)));
+	let labels = nodes.map(() => "");
+	let classes = 1;
+	loop((round) => {
+		if (round > nodes.length) return false;
+		const current = labels;
+		const next = templates.map((ts, i) => fnv(`${current[i] ?? ""}|${Arr.sort(ts.map((t) => render(t, current)), Order.String).join("\n")}`));
+		const nextClasses = MutableHashSet.size(MutableHashSet.fromIterable(next));
+		labels = next;
+		if (nextClasses === classes) return false;
+		classes = nextClasses;
+		return true;
+	});
+	const final = labels;
+	return {
+		nodes,
+		labels: MutableHashMap.fromIterable(nodes.map((n, i) => [n, final[i] ?? ""])),
+		byNode
+	};
+};
+/** `q` with its blank nodes renamed by `mapping` (those it does not map are kept). */
+const renameBlankNodes = (q, mapping) => mapTerms(q, (t) => isBlankNode(t) ? new BlankNode(Option.getOrElse(MutableHashMap.get(mapping, t.value), () => t.value)) : t);
+const rename = (q, mapping) => renameBlankNodes(q, mapping).key;
+/** The blank nodes of a partition grouped by label, in order. */
+const groupsOf = (p) => {
+	const groups = MutableHashMap.empty();
+	p.nodes.forEach((n) => {
+		const l = labelOf(p.labels, n);
+		const group = MutableHashMap.get(groups, l);
+		if (Option.isSome(group)) group.value.push(n);
+		else MutableHashMap.set(groups, l, [n]);
+	});
+	return groups;
+};
+/** The class of `node`: the nodes of `groups` with its label in `labels`. */
+const classOf = (groups, labels, node) => Option.getOrElse(MutableHashMap.get(groups, labelOf(labels, node)), () => []);
+/**
+* The public result of `bijection`: a native `ReadonlyMap`, copied once
+* from the search's map at the end.
+*/
+const toReadonlyMap = (mapping) => new Map(mapping);
+/**
+* Finds a blank node bijection from `self` to `that` under which the two
+* datasets are equal, if one exists.
+*
+* @since 0.1.0
+* @category isomorphism
+*/
+const bijection = (self, that) => {
+	if (self.size !== that.size) return Option.none();
+	const aBlank = [];
+	if (Iterable.some(self, (q) => {
+		if (!hasBlankNodes(q)) return !has(that, q);
+		aBlank.push(q);
+		return false;
+	})) return Option.none();
+	const bBlank = Arr.filter(Arr.fromIterable(that), (q) => hasBlankNodes(q));
+	if (aBlank.length !== bBlank.length) return Option.none();
+	if (Arr.isReadonlyArrayEmpty(aBlank)) return Option.some(toReadonlyMap(MutableHashMap.empty()));
+	const a = refine(aBlank);
+	const b = refine(bBlank);
+	if (a.nodes.length !== b.nodes.length) return Option.none();
+	const groupsB = groupsOf(b);
+	const groupsA = groupsOf(a);
+	if (!!Iterable.some(groupsA, ([l, g]) => !Option.exists(MutableHashMap.get(groupsB, l), (gb) => gb.length === g.length))) return Option.none();
+	const target = MutableHashSet.fromIterable(bBlank.map((q) => q.key));
+	const mapping = MutableHashMap.empty();
+	const used = MutableHashSet.empty();
+	const order = Arr.sort(a.nodes, Order.mapInput(Order.Number, (x) => classOf(groupsA, a.labels, x).length));
+	const consistent = (node) => !quadsOf(a, node).some((q) => {
+		return quadBlankNodes(q).every((x) => MutableHashMap.has(mapping, x)) && !MutableHashSet.has(target, rename(q, mapping));
+	});
+	const cursors = [0];
+	let found = false;
+	loop(() => {
+		const i = cursors.length - 1;
+		const node = order[i];
+		if (i < 0 || node === void 0) {
+			found = i === order.length;
+			return false;
+		}
+		const candidates = classOf(groupsB, a.labels, node);
+		const previous = MutableHashMap.get(mapping, node);
+		if (Option.isSome(previous)) {
+			MutableHashMap.remove(mapping, node);
+			MutableHashSet.remove(used, previous.value);
+		}
+		let next = cursors[i] ?? 0;
+		let advanced = false;
+		loop(() => {
+			const candidate = candidates[next];
+			if (candidate === void 0) return false;
+			next++;
+			if (MutableHashSet.has(used, candidate)) return true;
+			MutableHashMap.set(mapping, node, candidate);
+			MutableHashSet.add(used, candidate);
+			if (consistent(node)) {
+				advanced = true;
+				return false;
+			}
+			MutableHashMap.remove(mapping, node);
+			MutableHashSet.remove(used, candidate);
+			return true;
+		});
+		cursors[i] = next;
+		if (advanced) cursors.push(0);
+		else cursors.pop();
+		return true;
+	});
+	return found ? Option.some(toReadonlyMap(mapping)) : Option.none();
+};
+/**
+* Whether two datasets are isomorphic: equal up to a consistent renaming of
+* blank nodes.
+*
+* @since 0.1.0
+* @category isomorphism
+*/
+const isomorphic = dual(2, (self, that) => Option.isSome(bijection(self, that)));
+/**
+* Relabels blank nodes in a dataset with fresh labels `prefix0`, `prefix1`,
+* … in a deterministic order derived from their structural signatures.
+*
+* Isomorphic datasets without automorphic blank nodes yield identical
+* results; this is not a full canonicalisation algorithm.
+*
+* @since 0.1.0
+* @category isomorphism
+*/
+const relabel = (self, prefix = "c") => {
+	const blank = Array.from(self).filter(hasBlankNodes);
+	if (Arr.isReadonlyArrayEmpty(blank)) return self;
+	const { nodes, labels } = refine(blank);
+	const sorted = Arr.sort(nodes, Order.mapInput(Order.String, (x) => labelOf(labels, x)));
+	const mapping = MutableHashMap.fromIterable(sorted.map((n, i) => [n, `${prefix}${i}`]));
+	return map(self, (q) => renameBlankNodes(q, mapping));
+};
+export { relabel as i, bijection as n, isomorphic as r, Isomorphism_exports as t };
+
+//# sourceMappingURL=Isomorphism-BmqxhKyJ.mjs.map

package/dist/Isomorphism-BmqxhKyJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Isomorphism-BmqxhKyJ.mjs","names":["Term.isBlankNode","Term.isTriple","Term.mapTerms","Term.BlankNode","Term.hasBlankNodes","Dataset.has","Dataset.map"],"sources":["../src/Isomorphism.ts"],"sourcesContent":["/**\n * Blank-node-aware dataset comparison (RDF graph isomorphism).\n *\n * Uses iterative signature refinement to partition blank nodes, then a\n * backtracking search over the (usually tiny) ambiguous classes.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport { dual } from 'effect/Function';\nimport * as Iterable from 'effect/Iterable';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\nimport * as Predicate from 'effect/Predicate';\nimport * as Dataset from './Dataset.ts';\nimport { loop } from './internal/loop.ts';\nimport * as Term from './Term.ts';\n\n/** Blank node labels, by blank node label. */\ntype Labels = MutableHashMap.MutableHashMap<string, string>;\n\nconst fnv = (s: string): string => {\n  let h1 = 0x811c9dc5;\n  let h2 = 0x01000193;\n  loop((i) => {\n    if (i >= s.length) return false;\n    const c = s.charCodeAt(i);\n    h1 = Math.imul(h1 ^ c, 0x01000193);\n    h2 = Math.imul(h2 ^ c, 0x5bd1e995);\n    return true;\n  });\n  return (h1 >>> 0).toString(36) + (h2 >>> 0).toString(36);\n};\n\n/** Appends the blank nodes of `t` (and of the triple terms inside it) to `out`, each once. */\nconst collectBlankNodes = (t: Term.Term, out: Array<string>): void => {\n  if (Term.isBlankNode(t)) {\n    if (!out.includes(t.value)) out.push(t.value);\n  } else if (Term.isTriple(t)) {\n    collectBlankNodes(t.subject, out);\n    collectBlankNodes(t.object, out);\n  }\n};\n\n/** The distinct blank nodes of a quad, in order of first occurrence. */\nconst quadBlankNodes = (q: Term.Quad): ReadonlyArray<string> => {\n  const out: Array<string> = [];\n  collectBlankNodes(q.subject, out);\n  collectBlankNodes(q.object, out);\n  collectBlankNodes(q.graph, out);\n  return out;\n};\n\nconst labelOf = (labels: Labels, node: string): string =>\n  Option.getOrElse(MutableHashMap.get(labels, node), () => '');\n\n/**\n * A quad's signature for one of its blank nodes, compiled once: text, and in\n * between the indexes (into `Partition.nodes`) of the other blank nodes,\n * whose current labels each refinement round fills in. The node itself is\n * `@self`.\n */\ntype Template = ReadonlyArray<string | number>;\n\nconst compile = (\n  t: Term.Term,\n  self: string,\n  index: MutableHashMap.MutableHashMap<string, number>,\n  out: Array<string | number>,\n): void => {\n  if (Term.isBlankNode(t)) {\n    if (t.value === self) out.push('@self');\n    else out.push(Option.getOrElse(MutableHashMap.get(index, t.value), () => '@'));\n  } else if (Term.isTriple(t)) {\n    out.push('<<');\n    compile(t.subject, self, index, out);\n    out.push(` ${t.predicate.key} `);\n    compile(t.object, self, index, out);\n    out.push('>>');\n  } else out.push(t.key);\n};\n\nconst template = (\n  q: Term.Quad,\n  self: string,\n  index: MutableHashMap.MutableHashMap<string, number>,\n): Template => {\n  const out: Array<string | number> = [];\n  compile(q.subject, self, index, out);\n  out.push(` ${q.predicate.key} `);\n  compile(q.object, self, index, out);\n  out.push(' ');\n  compile(q.graph, self, index, out);\n  return out;\n};\n\n/** A template with the blank nodes' labels filled in. */\nconst render = (t: Template, labels: ReadonlyArray<string>): string =>\n  t.map((part) => (Predicate.isString(part) ? part : `@${labels[part] ?? ''}`)).join('');\n\ninterface Partition {\n  readonly nodes: ReadonlyArray<string>;\n  readonly labels: Labels;\n  readonly byNode: MutableHashMap.MutableHashMap<string, Array<Term.Quad>>;\n}\n\n/** The quads a blank node occurs in. */\nconst quadsOf = (p: Partition, node: string): ReadonlyArray<Term.Quad> =>\n  Option.getOrElse(MutableHashMap.get(p.byNode, node), () => []);\n\nconst refine = (quads: ReadonlyArray<Term.Quad>): Partition => {\n  const byNode = MutableHashMap.empty<string, Array<Term.Quad>>();\n  quads.forEach((q) => {\n    quadBlankNodes(q).forEach((b) => {\n      const list = MutableHashMap.get(byNode, b);\n      if (Option.isSome(list)) list.value.push(q);\n      else MutableHashMap.set(byNode, b, [q]);\n    });\n  });\n  const nodes = Arr.fromIterable(MutableHashMap.keys(byNode));\n  const index = MutableHashMap.fromIterable(nodes.map((n, i) => [n, i] as const));\n  const templates = nodes.map((n) =>\n    Option.getOrElse(MutableHashMap.get(byNode, n), () => []).map((q) => template(q, n, index)),\n  );\n  let labels: ReadonlyArray<string> = nodes.map(() => '');\n  let classes = 1;\n  // Refine until the number of classes stops growing (at most one round per node)\n  loop((round) => {\n    if (round > nodes.length) return false;\n    const current = labels;\n    const next = templates.map((ts, i) =>\n      fnv(\n        `${current[i] ?? ''}|${Arr.sort(\n          ts.map((t) => render(t, current)),\n          Order.String,\n        ).join('\\n')}`,\n      ),\n    );\n    const nextClasses = MutableHashSet.size(MutableHashSet.fromIterable(next));\n    labels = next;\n    if (nextClasses === classes) return false;\n    classes = nextClasses;\n    return true;\n  });\n  const final = labels;\n  return {\n    nodes,\n    labels: MutableHashMap.fromIterable(nodes.map((n, i) => [n, final[i] ?? ''] as const)),\n    byNode,\n  };\n};\n\n/** `q` with its blank nodes renamed by `mapping` (those it does not map are kept). */\nconst renameBlankNodes = (q: Term.Quad, mapping: Labels): Term.Quad =>\n  Term.mapTerms(q, (t) =>\n    Term.isBlankNode(t)\n      ? new Term.BlankNode(Option.getOrElse(MutableHashMap.get(mapping, t.value), () => t.value))\n      : t,\n  );\n\nconst rename = (q: Term.Quad, mapping: Labels): string => renameBlankNodes(q, mapping).key;\n\n/** The blank nodes of a partition grouped by label, in order. */\nconst groupsOf = (p: Partition): MutableHashMap.MutableHashMap<string, Array<string>> => {\n  const groups = MutableHashMap.empty<string, Array<string>>();\n  p.nodes.forEach((n) => {\n    const l = labelOf(p.labels, n);\n    const group = MutableHashMap.get(groups, l);\n    if (Option.isSome(group)) group.value.push(n);\n    else MutableHashMap.set(groups, l, [n]);\n  });\n  return groups;\n};\n\n/** The class of `node`: the nodes of `groups` with its label in `labels`. */\nconst classOf = (\n  groups: MutableHashMap.MutableHashMap<string, ReadonlyArray<string>>,\n  labels: Labels,\n  node: string,\n): ReadonlyArray<string> =>\n  Option.getOrElse(MutableHashMap.get(groups, labelOf(labels, node)), () => []);\n\n/**\n * The public result of `bijection`: a native `ReadonlyMap`, copied once\n * from the search's map at the end.\n */\nconst toReadonlyMap = (mapping: Labels): ReadonlyMap<string, string> => new Map(mapping);\n\n/**\n * Finds a blank node bijection from `self` to `that` under which the two\n * datasets are equal, if one exists.\n *\n * @since 0.1.0\n * @category isomorphism\n */\nexport const bijection = (\n  self: Dataset.Dataset,\n  that: Dataset.Dataset,\n): Option.Option<ReadonlyMap<string, string>> => {\n  if (self.size !== that.size) return Option.none();\n  const aBlank: Array<Term.Quad> = [];\n  const groundMissing = Iterable.some(self, (q) => {\n    if (!Term.hasBlankNodes(q)) return !Dataset.has(that, q);\n    aBlank.push(q);\n    return false;\n  });\n  if (groundMissing) return Option.none();\n  const bBlank = Arr.filter(Arr.fromIterable(that), (q) => Term.hasBlankNodes(q));\n  if (aBlank.length !== bBlank.length) return Option.none();\n  if (Arr.isReadonlyArrayEmpty(aBlank)) return Option.some(toReadonlyMap(MutableHashMap.empty()));\n\n  const a = refine(aBlank);\n  const b = refine(bBlank);\n  if (a.nodes.length !== b.nodes.length) return Option.none();\n\n  const groupsB = groupsOf(b);\n  const groupsA = groupsOf(a);\n  const sameClasses = !Iterable.some(\n    groupsA,\n    ([l, g]) => !Option.exists(MutableHashMap.get(groupsB, l), (gb) => gb.length === g.length),\n  );\n  if (!sameClasses) return Option.none();\n\n  const target = MutableHashSet.fromIterable(bBlank.map((q) => q.key));\n  const mapping: Labels = MutableHashMap.empty();\n  const used = MutableHashSet.empty<string>();\n  // Assign unambiguous nodes first, then search the rest smallest class first.\n  const order = Arr.sort(\n    a.nodes,\n    Order.mapInput(Order.Number, (x: string) => classOf(groupsA, a.labels, x).length),\n  );\n\n  const consistent = (node: string): boolean =>\n    !quadsOf(a, node).some((q) => {\n      const complete = quadBlankNodes(q).every((x) => MutableHashMap.has(mapping, x));\n      return complete && !MutableHashSet.has(target, rename(q, mapping));\n    });\n\n  // Iterative depth-first search (graphs can have many thousands of blank nodes).\n  const cursors: Array<number> = [0];\n  let found = false;\n  loop(() => {\n    const i = cursors.length - 1;\n    const node = order[i];\n    if (i < 0 || node === undefined) {\n      // The search is exhausted, or every node is assigned\n      found = i === order.length;\n      return false;\n    }\n    const candidates = classOf(groupsB, a.labels, node);\n    const previous = MutableHashMap.get(mapping, node);\n    if (Option.isSome(previous)) {\n      MutableHashMap.remove(mapping, node);\n      MutableHashSet.remove(used, previous.value);\n    }\n    let next = cursors[i] ?? 0;\n    let advanced = false;\n    loop(() => {\n      const candidate = candidates[next];\n      if (candidate === undefined) return false;\n      next++;\n      if (MutableHashSet.has(used, candidate)) return true;\n      MutableHashMap.set(mapping, node, candidate);\n      MutableHashSet.add(used, candidate);\n      if (consistent(node)) {\n        advanced = true;\n        return false;\n      }\n      MutableHashMap.remove(mapping, node);\n      MutableHashSet.remove(used, candidate);\n      return true;\n    });\n    cursors[i] = next;\n    if (advanced) cursors.push(0);\n    else cursors.pop();\n    return true;\n  });\n  return found ? Option.some(toReadonlyMap(mapping)) : Option.none();\n};\n\n/**\n * Whether two datasets are isomorphic: equal up to a consistent renaming of\n * blank nodes.\n *\n * @since 0.1.0\n * @category isomorphism\n */\nexport const isomorphic: {\n  (that: Dataset.Dataset): (self: Dataset.Dataset) => boolean;\n  (self: Dataset.Dataset, that: Dataset.Dataset): boolean;\n} = dual(2, (self: Dataset.Dataset, that: Dataset.Dataset): boolean =>\n  Option.isSome(bijection(self, that)),\n);\n\n/**\n * Relabels blank nodes in a dataset with fresh labels `prefix0`, `prefix1`,\n * … in a deterministic order derived from their structural signatures.\n *\n * Isomorphic datasets without automorphic blank nodes yield identical\n * results; this is not a full canonicalisation algorithm.\n *\n * @since 0.1.0\n * @category isomorphism\n */\nexport const relabel = (self: Dataset.Dataset, prefix = 'c'): Dataset.Dataset => {\n  const blank = Array.from(self).filter(Term.hasBlankNodes);\n  if (Arr.isReadonlyArrayEmpty(blank)) return self;\n  const { nodes, labels } = refine(blank);\n  const sorted = Arr.sort(\n    nodes,\n    Order.mapInput(Order.String, (x: string) => labelOf(labels, x)),\n  );\n  const mapping: Labels = MutableHashMap.fromIterable(\n    sorted.map((n, i) => [n, `${prefix}${i}`] as const),\n  );\n  return Dataset.map(self, (q) => renameBlankNodes(q, mapping));\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,OAAO,MAAsB;CACjC,IAAI,KAAK;CACT,IAAI,KAAK;CACT,MAAM,MAAM;EACV,IAAI,KAAK,EAAE,QAAQ,OAAO;EAC1B,MAAM,IAAI,EAAE,WAAW,CAAC;EACxB,KAAK,KAAK,KAAK,KAAK,GAAG,QAAU;EACjC,KAAK,KAAK,KAAK,KAAK,GAAG,UAAU;EACjC,OAAO;CACT,CAAC;CACD,QAAQ,OAAO,EAAA,CAAG,SAAS,EAAE,KAAK,OAAO,EAAA,CAAG,SAAS,EAAE;AACzD;;AAGA,MAAM,qBAAqB,GAAc,QAA6B;CACpE,IAAIA,YAAiB,CAAC,GAChB;MAAA,CAAC,IAAI,SAAS,EAAE,KAAK,GAAG,IAAI,KAAK,EAAE,KAAK;CAAA,OACvC,IAAIC,SAAc,CAAC,GAAG;EAC3B,kBAAkB,EAAE,SAAS,GAAG;EAChC,kBAAkB,EAAE,QAAQ,GAAG;CACjC;AACF;;AAGA,MAAM,kBAAkB,MAAwC;CAC9D,MAAM,MAAqB,CAAC;CAC5B,kBAAkB,EAAE,SAAS,GAAG;CAChC,kBAAkB,EAAE,QAAQ,GAAG;CAC/B,kBAAkB,EAAE,OAAO,GAAG;CAC9B,OAAO;AACT;AAEA,MAAM,WAAW,QAAgB,SAC/B,OAAO,UAAU,eAAe,IAAI,QAAQ,IAAI,SAAS,EAAE;AAU7D,MAAM,WACJ,GACA,MACA,OACA,QACS;CACT,IAAID,YAAiB,CAAC,GAAG;EACvB,IAAI,EAAE,UAAU,MAAM,IAAI,KAAK,OAAO;OACjC,IAAI,KAAK,OAAO,UAAU,eAAe,IAAI,OAAO,EAAE,KAAK,SAAS,GAAG,CAAC;CAC/E,OAAO,IAAIC,SAAc,CAAC,GAAG;EAC3B,IAAI,KAAK,IAAI;EACb,QAAQ,EAAE,SAAS,MAAM,OAAO,GAAG;EACnC,IAAI,KAAK,IAAI,EAAE,UAAU,IAAI,EAAE;EAC/B,QAAQ,EAAE,QAAQ,MAAM,OAAO,GAAG;EAClC,IAAI,KAAK,IAAI;CACf,OAAO,IAAI,KAAK,EAAE,GAAG;AACvB;AAEA,MAAM,YACJ,GACA,MACA,UACa;CACb,MAAM,MAA8B,CAAC;CACrC,QAAQ,EAAE,SAAS,MAAM,OAAO,GAAG;CACnC,IAAI,KAAK,IAAI,EAAE,UAAU,IAAI,EAAE;CAC/B,QAAQ,EAAE,QAAQ,MAAM,OAAO,GAAG;CAClC,IAAI,KAAK,GAAG;CACZ,QAAQ,EAAE,OAAO,MAAM,OAAO,GAAG;CACjC,OAAO;AACT;;AAGA,MAAM,UAAU,GAAa,WAC3B,EAAE,KAAK,SAAU,UAAU,SAAS,IAAI,IAAI,OAAO,IAAI,OAAO,SAAS,IAAK,CAAC,CAAC,KAAK,EAAE;;AASvF,MAAM,WAAW,GAAc,SAC7B,OAAO,UAAU,eAAe,IAAI,EAAE,QAAQ,IAAI,SAAS,CAAC,CAAC;AAE/D,MAAM,UAAU,UAA+C;CAC7D,MAAM,SAAS,eAAe,MAAgC;CAC9D,MAAM,SAAS,MAAM;EACnB,eAAe,CAAC,CAAC,CAAC,SAAS,MAAM;GAC/B,MAAM,OAAO,eAAe,IAAI,QAAQ,CAAC;GACzC,IAAI,OAAO,OAAO,IAAI,GAAG,KAAK,MAAM,KAAK,CAAC;QACrC,eAAe,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;EACxC,CAAC;CACH,CAAC;CACD,MAAM,QAAQ,IAAI,aAAa,eAAe,KAAK,MAAM,CAAC;CAC1D,MAAM,QAAQ,eAAe,aAAa,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAU,CAAC;CAC9E,MAAM,YAAY,MAAM,KAAK,MAC3B,OAAO,UAAU,eAAe,IAAI,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,MAAM,SAAS,GAAG,GAAG,KAAK,CAAC,CAC5F;CACA,IAAI,SAAgC,MAAM,UAAU,EAAE;CACtD,IAAI,UAAU;CAEd,MAAM,UAAU;EACd,IAAI,QAAQ,MAAM,QAAQ,OAAO;EACjC,MAAM,UAAU;EAChB,MAAM,OAAO,UAAU,KAAK,IAAI,MAC9B,IACE,GAAG,QAAQ,MAAM,GAAG,GAAG,IAAI,KACzB,GAAG,KAAK,MAAM,OAAO,GAAG,OAAO,CAAC,GAChC,MAAM,MACR,CAAC,CAAC,KAAK,IAAI,GACb,CACF;EACA,MAAM,cAAc,eAAe,KAAK,eAAe,aAAa,IAAI,CAAC;EACzE,SAAS;EACT,IAAI,gBAAgB,SAAS,OAAO;EACpC,UAAU;EACV,OAAO;CACT,CAAC;CACD,MAAM,QAAQ;CACd,OAAO;EACL;EACA,QAAQ,eAAe,aAAa,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,MAAM,MAAM,EAAE,CAAU,CAAC;EACrF;CACF;AACF;;AAGA,MAAM,oBAAoB,GAAc,YACtCC,SAAc,IAAI,MAChBF,YAAiB,CAAC,IACd,IAAIG,UAAe,OAAO,UAAU,eAAe,IAAI,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,CAAC,IACxF,CACN;AAEF,MAAM,UAAU,GAAc,YAA4B,iBAAiB,GAAG,OAAO,CAAC,CAAC;;AAGvF,MAAM,YAAY,MAAuE;CACvF,MAAM,SAAS,eAAe,MAA6B;CAC3D,EAAE,MAAM,SAAS,MAAM;EACrB,MAAM,IAAI,QAAQ,EAAE,QAAQ,CAAC;EAC7B,MAAM,QAAQ,eAAe,IAAI,QAAQ,CAAC;EAC1C,IAAI,OAAO,OAAO,KAAK,GAAG,MAAM,MAAM,KAAK,CAAC;OACvC,eAAe,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;CACxC,CAAC;CACD,OAAO;AACT;;AAGA,MAAM,WACJ,QACA,QACA,SAEA,OAAO,UAAU,eAAe,IAAI,QAAQ,QAAQ,QAAQ,IAAI,CAAC,SAAS,CAAC,CAAC;;;;;AAM9E,MAAM,iBAAiB,YAAiD,IAAI,IAAI,OAAO;;;;;;;;AASvF,MAAa,aACX,MACA,SAC+C;CAC/C,IAAI,KAAK,SAAS,KAAK,MAAM,OAAO,OAAO,KAAK;CAChD,MAAM,SAA2B,CAAC;CAMlC,IALsB,SAAS,KAAK,OAAO,MAAM;EAC/C,IAAI,CAACC,cAAmB,CAAC,GAAG,OAAO,CAACC,IAAY,MAAM,CAAC;EACvD,OAAO,KAAK,CAAC;EACb,OAAO;CACT,CACgB,GAAG,OAAO,OAAO,KAAK;CACtC,MAAM,SAAS,IAAI,OAAO,IAAI,aAAa,IAAI,IAAI,MAAMD,cAAmB,CAAC,CAAC;CAC9E,IAAI,OAAO,WAAW,OAAO,QAAQ,OAAO,OAAO,KAAK;CACxD,IAAI,IAAI,qBAAqB,MAAM,GAAG,OAAO,OAAO,KAAK,cAAc,eAAe,MAAM,CAAC,CAAC;CAE9F,MAAM,IAAI,OAAO,MAAM;CACvB,MAAM,IAAI,OAAO,MAAM;CACvB,IAAI,EAAE,MAAM,WAAW,EAAE,MAAM,QAAQ,OAAO,OAAO,KAAK;CAE1D,MAAM,UAAU,SAAS,CAAC;CAC1B,MAAM,UAAU,SAAS,CAAC;CAK1B,IAAI,CAAC,CAJgB,SAAS,KAC5B,UACC,CAAC,GAAG,OAAO,CAAC,OAAO,OAAO,eAAe,IAAI,SAAS,CAAC,IAAI,OAAO,GAAG,WAAW,EAAE,MAAM,CAC3F,GACkB,OAAO,OAAO,KAAK;CAErC,MAAM,SAAS,eAAe,aAAa,OAAO,KAAK,MAAM,EAAE,GAAG,CAAC;CACnE,MAAM,UAAkB,eAAe,MAAM;CAC7C,MAAM,OAAO,eAAe,MAAc;CAE1C,MAAM,QAAQ,IAAI,KAChB,EAAE,OACF,MAAM,SAAS,MAAM,SAAS,MAAc,QAAQ,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAClF;CAEA,MAAM,cAAc,SAClB,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,MAAM,MAAM;EAE5B,OADiB,eAAe,CAAC,CAAC,CAAC,OAAO,MAAM,eAAe,IAAI,SAAS,CAAC,CAC/D,KAAK,CAAC,eAAe,IAAI,QAAQ,OAAO,GAAG,OAAO,CAAC;CACnE,CAAC;CAGH,MAAM,UAAyB,CAAC,CAAC;CACjC,IAAI,QAAQ;CACZ,WAAW;EACT,MAAM,IAAI,QAAQ,SAAS;EAC3B,MAAM,OAAO,MAAM;EACnB,IAAI,IAAI,KAAK,SAAS,KAAA,GAAW;GAE/B,QAAQ,MAAM,MAAM;GACpB,OAAO;EACT;EACA,MAAM,aAAa,QAAQ,SAAS,EAAE,QAAQ,IAAI;EAClD,MAAM,WAAW,eAAe,IAAI,SAAS,IAAI;EACjD,IAAI,OAAO,OAAO,QAAQ,GAAG;GAC3B,eAAe,OAAO,SAAS,IAAI;GACnC,eAAe,OAAO,MAAM,SAAS,KAAK;EAC5C;EACA,IAAI,OAAO,QAAQ,MAAM;EACzB,IAAI,WAAW;EACf,WAAW;GACT,MAAM,YAAY,WAAW;GAC7B,IAAI,cAAc,KAAA,GAAW,OAAO;GACpC;GACA,IAAI,eAAe,IAAI,MAAM,SAAS,GAAG,OAAO;GAChD,eAAe,IAAI,SAAS,MAAM,SAAS;GAC3C,eAAe,IAAI,MAAM,SAAS;GAClC,IAAI,WAAW,IAAI,GAAG;IACpB,WAAW;IACX,OAAO;GACT;GACA,eAAe,OAAO,SAAS,IAAI;GACnC,eAAe,OAAO,MAAM,SAAS;GACrC,OAAO;EACT,CAAC;EACD,QAAQ,KAAK;EACb,IAAI,UAAU,QAAQ,KAAK,CAAC;OACvB,QAAQ,IAAI;EACjB,OAAO;CACT,CAAC;CACD,OAAO,QAAQ,OAAO,KAAK,cAAc,OAAO,CAAC,IAAI,OAAO,KAAK;AACnE;;;;;;;;AASA,MAAa,aAGT,KAAK,IAAI,MAAuB,SAClC,OAAO,OAAO,UAAU,MAAM,IAAI,CAAC,CACrC;;;;;;;;;;;AAYA,MAAa,WAAW,MAAuB,SAAS,QAAyB;CAC/E,MAAM,QAAQ,MAAM,KAAK,IAAI,CAAC,CAAC,OAAOA,aAAkB;CACxD,IAAI,IAAI,qBAAqB,KAAK,GAAG,OAAO;CAC5C,MAAM,EAAE,OAAO,WAAW,OAAO,KAAK;CACtC,MAAM,SAAS,IAAI,KACjB,OACA,MAAM,SAAS,MAAM,SAAS,MAAc,QAAQ,QAAQ,CAAC,CAAC,CAChE;CACA,MAAM,UAAkB,eAAe,aACrC,OAAO,KAAK,GAAG,MAAM,CAAC,GAAG,GAAG,SAAS,GAAG,CAAU,CACpD;CACA,OAAOE,IAAY,OAAO,MAAM,iBAAiB,GAAG,OAAO,CAAC;AAC9D"}