@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Lexical-Cg0JHrf6.mjs

@@ -0,0 +1,243 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { A as escapeString, B as isNamedNode, Y as literal, k as escapeIri, o as Literal } from "./Term-CFLG1qu4.mjs";
+import * as Match from "effect/Match";
+// src/ntriples/Lexical.ts
+/**
+* Lexical rules shared by the N-Triples family of RDF syntaxes (N-Triples,
+* N-Quads, Turtle and TriG): character classes, escape decoding, language
+* tags with base direction, and canonical term formatting.
+*
+* These are low-level, pure helpers; most users want the `NTriples` and
+* `NQuads` modules instead.
+*
+* @since 0.1.0
+*/
+var Lexical_exports = /* @__PURE__ */ __exportAll({
+	blankNodeLabel: () => blankNodeLabel,
+	decodeEchar: () => decodeEchar,
+	decodeUchar: () => decodeUchar,
+	formatIri: () => formatIri,
+	formatLiteral: () => formatLiteral,
+	formatTerm: () => formatTerm,
+	isAbsoluteIri: () => isAbsoluteIri,
+	isBlankNodeLabel: () => isBlankNodeLabel,
+	isDigit: () => isDigit,
+	isHex: () => isHex,
+	isIriChar: () => isIriChar,
+	isPnChars: () => isPnChars,
+	isPnCharsBase: () => isPnCharsBase,
+	isPnCharsU: () => isPnCharsU,
+	isWritableIri: () => isWritableIri,
+	makeLiteral: () => makeLiteral,
+	parseLanguageTag: () => parseLanguageTag
+});
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const RDF_LANG_STRING = `${RDF}langString`;
+const RDF_DIR_LANG_STRING = `${RDF}dirLangString`;
+const XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+/**
+* `PN_CHARS_BASE` from the Turtle / N-Triples grammars.
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isPnCharsBase = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+/**
+* `PN_CHARS_U`: `PN_CHARS_BASE` or `_`.
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isPnCharsU = (c) => c === 95 || isPnCharsBase(c);
+/**
+* `PN_CHARS`: `PN_CHARS_U`, `-`, digits, `·` and combining marks.
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isPnChars = (c) => isPnCharsU(c) || c === 45 || c >= 48 && c <= 57 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+/**
+* Whether a code point is an ASCII digit.
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isDigit = (c) => c >= 48 && c <= 57;
+/**
+* Whether a code point is an ASCII hexadecimal digit.
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isHex = (c) => c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+/**
+* Whether a code point may appear unescaped inside an `IRIREF`
+* (`[^#x00-#x20<>"{}|^`\]`).
+*
+* @since 0.1.0
+* @category character classes
+*/
+const isIriChar = (c) => c > 32 && c !== 60 && c !== 62 && c !== 34 && c !== 123 && c !== 125 && c !== 124 && c !== 94 && c !== 96 && c !== 92;
+const SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+/**
+* Whether a string is an absolute IRI reference (starts with a scheme).
+*
+* @since 0.1.0
+* @category validation
+*/
+const isAbsoluteIri = (iri) => SCHEME.test(iri);
+/**
+* Whether an IRI can be written as an N-Triples / Turtle `IRIREF`: it is
+* absolute and contains no characters that would need escaping.
+*
+* @since 0.1.0
+* @category validation
+*/
+const isWritableIri = (iri) => isAbsoluteIri(iri) && escapeIri(iri) === iri;
+/** The code point of a one-code-point string (as `Array.from` splits a string). */
+const codePointOf = (ch) => ch.codePointAt(0) ?? 0;
+const HEX_DIGITS = /^[0-9A-Fa-f]*$/;
+/**
+* Whether a string is a valid `BLANK_NODE_LABEL` (without the `_:`).
+*
+* @since 0.1.0
+* @category validation
+*/
+const isBlankNodeLabel = (label) => {
+	if (label === "") return false;
+	const codePoints = Array.from(label, codePointOf);
+	return codePoints.every((c, i) => i === 0 ? isPnCharsU(c) || isDigit(c) : isPnChars(c) || c === 46) && codePoints.at(-1) !== 46;
+};
+/**
+* Decodes a `UCHAR` (`\uXXXX` or `\UXXXXXXXX`) starting at `index`, which
+* must point at the backslash. Surrogate code points and values beyond
+* U+10FFFF are rejected.
+*
+* @since 0.1.0
+* @category escapes
+*/
+const decodeUchar = (input, index) => {
+	const kind = input.charCodeAt(index + 1);
+	const digits = kind === 117 ? 4 : kind === 85 ? 8 : 0;
+	if (digits === 0) return {
+		_tag: "Error",
+		message: "Invalid escape sequence"
+	};
+	const hex = input.slice(index + 2, index + 2 + digits);
+	if (hex.length !== digits || !HEX_DIGITS.test(hex)) return {
+		_tag: "Error",
+		message: "Invalid numeric escape sequence"
+	};
+	const value = parseInt(hex, 16);
+	if (value > 1114111) return {
+		_tag: "Error",
+		message: "Numeric escape is beyond U+10FFFF"
+	};
+	if (value >= 55296 && value <= 57343) return {
+		_tag: "Error",
+		message: "Numeric escape encodes a surrogate code point"
+	};
+	return {
+		_tag: "Ok",
+		value: String.fromCodePoint(value),
+		length: digits + 2
+	};
+};
+const echar = Match.type().pipe(Match.when(116, () => "	"), Match.when(98, () => "\b"), Match.when(110, () => "\n"), Match.when(114, () => "\r"), Match.when(102, () => "\f"), Match.when(34, () => "\""), Match.when(39, () => "'"), Match.when(92, () => "\\"), Match.orElse(() => void 0));
+/**
+* Decodes the string-escape (`ECHAR`) character following a backslash, if
+* it is one of `t b n r f " ' \`.
+*
+* @since 0.1.0
+* @category escapes
+*/
+const decodeEchar = (c) => echar(c);
+const LANG_DIR = /^([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)(?:--([a-zA-Z]+))?$/;
+/**
+* Parses the text of a `LANG_DIR` token (without the leading `@`). Returns
+* `undefined` when the tag or direction is invalid; directions must be
+* `ltr` or `rtl`.
+*
+* @since 0.1.0
+* @category validation
+*/
+const parseLanguageTag = (text) => {
+	const m = LANG_DIR.exec(text);
+	if (m === null) return void 0;
+	const direction = m[2];
+	if (direction !== void 0 && direction !== "ltr" && direction !== "rtl") return void 0;
+	return {
+		language: m[1] ?? "",
+		direction
+	};
+};
+/**
+* Builds a literal from a lexical form and an optional language tag or
+* datatype, rejecting the language-string datatypes used without a tag.
+* Returns an error message on failure.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeLiteral = (value, annotation) => {
+	if (annotation === void 0) return literal(value);
+	if (isNamedNode(annotation)) {
+		if (annotation.value === RDF_LANG_STRING || annotation.value === RDF_DIR_LANG_STRING) return `The datatype ${annotation.key} requires a language tag`;
+		return new Literal(value, annotation);
+	}
+	return literal(value, annotation);
+};
+/**
+* Encodes an arbitrary blank node label as a valid N-Triples label. Valid
+* labels are returned unchanged.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const blankNodeLabel = (label) => {
+	if (isBlankNodeLabel(label)) return label;
+	return `x${Array.from(label, (ch) => {
+		const c = codePointOf(ch);
+		return isPnCharsBase(c) || isDigit(c) ? ch : `_${c.toString(16)}_`;
+	}).join("")}`;
+};
+/**
+* Formats an IRI as a canonical `IRIREF`.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatIri = (iri) => `<${escapeIri(iri)}>`;
+/**
+* Formats a literal in canonical N-Triples form: canonical string escapes,
+* lower-case language tags, and no datatype for `xsd:string`.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatLiteral = (literal) => {
+	const lexical = `"${escapeString(literal.value)}"`;
+	if (literal.language !== "") {
+		const language = literal.language.toLowerCase();
+		return literal.direction === void 0 ? `${lexical}@${language}` : `${lexical}@${language}--${literal.direction}`;
+	}
+	if (literal.datatype.value === XSD_STRING) return lexical;
+	return `${lexical}^^${formatIri(literal.datatype.value)}`;
+};
+const formatTermMatch = Match.type().pipe(Match.tag("NamedNode", (term) => formatIri(term.value)), Match.tag("BlankNode", (term) => `_:${blankNodeLabel(term.value)}`), Match.tag("Literal", (term) => formatLiteral(term)), Match.tag("Triple", (term) => {
+	const s = formatTerm(term.subject);
+	const o = formatTerm(term.object);
+	return s === void 0 || o === void 0 ? void 0 : `<<( ${s} ${formatIri(term.predicate.value)} ${o} )>>`;
+}), Match.orElse(() => void 0));
+/**
+* Formats a ground term (IRI, blank node, literal or triple term) in
+* canonical N-Triples form. Returns `undefined` for variables and the
+* default graph, which have no N-Triples representation.
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatTerm = (term) => formatTermMatch(term);
+export { makeLiteral as _, formatIri as a, isAbsoluteIri as c, isHex as d, isIriChar as f, isWritableIri as g, isPnCharsU as h, decodeUchar as i, isBlankNodeLabel as l, isPnCharsBase as m, blankNodeLabel as n, formatLiteral as o, isPnChars as p, decodeEchar as r, formatTerm as s, Lexical_exports as t, isDigit as u, parseLanguageTag as v };
+
+//# sourceMappingURL=Lexical-Cg0JHrf6.mjs.map

package/dist/Lexical-Cg0JHrf6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lexical-Cg0JHrf6.mjs","names":["Term.escapeIri","Term.literal","Term.isNamedNode","Term.Literal","Term.escapeString"],"sources":["../src/ntriples/Lexical.ts"],"sourcesContent":["/**\n * Lexical rules shared by the N-Triples family of RDF syntaxes (N-Triples,\n * N-Quads, Turtle and TriG): character classes, escape decoding, language\n * tags with base direction, and canonical term formatting.\n *\n * These are low-level, pure helpers; most users want the `NTriples` and\n * `NQuads` modules instead.\n *\n * @since 0.1.0\n */\nimport * as Term from '../Term.ts';\nimport * as Match from 'effect/Match';\n\nconst RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';\nconst RDF_LANG_STRING = `${RDF}langString`;\nconst RDF_DIR_LANG_STRING = `${RDF}dirLangString`;\nconst XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';\n\n/**\n * `PN_CHARS_BASE` from the Turtle / N-Triples grammars.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isPnCharsBase = (c: number): boolean =>\n  (c >= 0x41 && c <= 0x5a) ||\n  (c >= 0x61 && c <= 0x7a) ||\n  (c >= 0xc0 && c <= 0xd6) ||\n  (c >= 0xd8 && c <= 0xf6) ||\n  (c >= 0xf8 && c <= 0x2ff) ||\n  (c >= 0x370 && c <= 0x37d) ||\n  (c >= 0x37f && c <= 0x1fff) ||\n  (c >= 0x200c && c <= 0x200d) ||\n  (c >= 0x2070 && c <= 0x218f) ||\n  (c >= 0x2c00 && c <= 0x2fef) ||\n  (c >= 0x3001 && c <= 0xd7ff) ||\n  (c >= 0xf900 && c <= 0xfdcf) ||\n  (c >= 0xfdf0 && c <= 0xfffd) ||\n  (c >= 0x10000 && c <= 0xeffff);\n\n/**\n * `PN_CHARS_U`: `PN_CHARS_BASE` or `_`.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isPnCharsU = (c: number): boolean => c === 0x5f || isPnCharsBase(c);\n\n/**\n * `PN_CHARS`: `PN_CHARS_U`, `-`, digits, `·` and combining marks.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isPnChars = (c: number): boolean =>\n  isPnCharsU(c) ||\n  c === 0x2d ||\n  (c >= 0x30 && c <= 0x39) ||\n  c === 0xb7 ||\n  (c >= 0x300 && c <= 0x36f) ||\n  (c >= 0x203f && c <= 0x2040);\n\n/**\n * Whether a code point is an ASCII digit.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isDigit = (c: number): boolean => c >= 0x30 && c <= 0x39;\n\n/**\n * Whether a code point is an ASCII hexadecimal digit.\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isHex = (c: number): boolean =>\n  (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66);\n\n/**\n * Whether a code point may appear unescaped inside an `IRIREF`\n * (`[^#x00-#x20<>\"{}|^`\\]`).\n *\n * @since 0.1.0\n * @category character classes\n */\nexport const isIriChar = (c: number): boolean =>\n  c > 0x20 &&\n  c !== 0x3c && // <\n  c !== 0x3e && // >\n  c !== 0x22 && // \"\n  c !== 0x7b && // {\n  c !== 0x7d && // }\n  c !== 0x7c && // |\n  c !== 0x5e && // ^\n  c !== 0x60 && // `\n  c !== 0x5c; // \\\n\n// Hoisted: a regex literal makes a new `RegExp` each time it is evaluated, and this runs per IRI.\nconst SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*:/;\n\n/**\n * Whether a string is an absolute IRI reference (starts with a scheme).\n *\n * @since 0.1.0\n * @category validation\n */\nexport const isAbsoluteIri = (iri: string): boolean => SCHEME.test(iri);\n\n/**\n * Whether an IRI can be written as an N-Triples / Turtle `IRIREF`: it is\n * absolute and contains no characters that would need escaping.\n *\n * @since 0.1.0\n * @category validation\n */\nexport const isWritableIri = (iri: string): boolean =>\n  // `escapeIri` changes exactly the characters `isIriChar` rejects\n  isAbsoluteIri(iri) && Term.escapeIri(iri) === iri;\n\n/** The code point of a one-code-point string (as `Array.from` splits a string). */\nconst codePointOf = (ch: string): number => ch.codePointAt(0) ?? 0;\n\nconst HEX_DIGITS = /^[0-9A-Fa-f]*$/;\n\n/**\n * Whether a string is a valid `BLANK_NODE_LABEL` (without the `_:`).\n *\n * @since 0.1.0\n * @category validation\n */\nexport const isBlankNodeLabel = (label: string): boolean => {\n  if (label === '') return false;\n  const codePoints = Array.from(label, codePointOf);\n  return (\n    codePoints.every((c, i) =>\n      i === 0 ? isPnCharsU(c) || isDigit(c) : isPnChars(c) || c === 0x2e,\n    ) && codePoints.at(-1) !== 0x2e\n  );\n};\n\n/**\n * The result of decoding a numeric escape: the code point or an error\n * message.\n *\n * @since 0.1.0\n * @category escapes\n */\nexport type DecodedEscape =\n  | { readonly _tag: 'Ok'; readonly value: string; readonly length: number }\n  | { readonly _tag: 'Error'; readonly message: string };\n\n/**\n * Decodes a `UCHAR` (`\\uXXXX` or `\\UXXXXXXXX`) starting at `index`, which\n * must point at the backslash. Surrogate code points and values beyond\n * U+10FFFF are rejected.\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const decodeUchar = (input: string, index: number): DecodedEscape => {\n  const kind = input.charCodeAt(index + 1);\n  const digits = kind === 0x75 ? 4 : kind === 0x55 ? 8 : 0;\n  if (digits === 0) return { _tag: 'Error', message: 'Invalid escape sequence' };\n  const hex = input.slice(index + 2, index + 2 + digits);\n  if (hex.length !== digits || !HEX_DIGITS.test(hex)) {\n    return { _tag: 'Error', message: 'Invalid numeric escape sequence' };\n  }\n  const value = parseInt(hex, 16);\n  if (value > 0x10ffff) {\n    return { _tag: 'Error', message: 'Numeric escape is beyond U+10FFFF' };\n  }\n  if (value >= 0xd800 && value <= 0xdfff) {\n    return { _tag: 'Error', message: 'Numeric escape encodes a surrogate code point' };\n  }\n  return { _tag: 'Ok', value: String.fromCodePoint(value), length: digits + 2 };\n};\n\n// Built once: `decodeEchar` runs for every backslash escape a lexer reads.\nconst echar = Match.type<number>().pipe(\n  Match.when(0x74, () => '\\t'),\n  Match.when(0x62, () => '\\b'),\n  Match.when(0x6e, () => '\\n'),\n  Match.when(0x72, () => '\\r'),\n  Match.when(0x66, () => '\\f'),\n  Match.when(0x22, () => '\"'),\n  Match.when(0x27, () => \"'\"),\n  Match.when(0x5c, () => '\\\\'),\n  Match.orElse(() => undefined),\n);\n\n/**\n * Decodes the string-escape (`ECHAR`) character following a backslash, if\n * it is one of `t b n r f \" ' \\`.\n *\n * @since 0.1.0\n * @category escapes\n */\nexport const decodeEchar = (c: number): string | undefined => echar(c);\n\n/**\n * A language tag with an optional base direction.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LanguageTag {\n  readonly language: string;\n  readonly direction: Term.Direction | undefined;\n}\n\nconst LANG_DIR = /^([a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*)(?:--([a-zA-Z]+))?$/;\n\n/**\n * Parses the text of a `LANG_DIR` token (without the leading `@`). Returns\n * `undefined` when the tag or direction is invalid; directions must be\n * `ltr` or `rtl`.\n *\n * @since 0.1.0\n * @category validation\n */\nexport const parseLanguageTag = (text: string): LanguageTag | undefined => {\n  const m = LANG_DIR.exec(text);\n  if (m === null) return undefined;\n  const direction = m[2];\n  if (direction !== undefined && direction !== 'ltr' && direction !== 'rtl') return undefined;\n  return { language: m[1] ?? '', direction };\n};\n\n/**\n * Builds a literal from a lexical form and an optional language tag or\n * datatype, rejecting the language-string datatypes used without a tag.\n * Returns an error message on failure.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeLiteral = (\n  value: string,\n  annotation: LanguageTag | Term.NamedNode | undefined,\n): Term.Literal | string => {\n  if (annotation === undefined) return Term.literal(value);\n  if (Term.isNamedNode(annotation)) {\n    if (annotation.value === RDF_LANG_STRING || annotation.value === RDF_DIR_LANG_STRING) {\n      return `The datatype ${annotation.key} requires a language tag`;\n    }\n    return new Term.Literal(value, annotation);\n  }\n  return Term.literal(value, annotation);\n};\n\n// -----------------------------------------------------------------------------\n// Canonical formatting\n// -----------------------------------------------------------------------------\n\n/**\n * Encodes an arbitrary blank node label as a valid N-Triples label. Valid\n * labels are returned unchanged.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const blankNodeLabel = (label: string): string => {\n  if (isBlankNodeLabel(label)) return label;\n  return `x${Array.from(label, (ch) => {\n    const c = codePointOf(ch);\n    return isPnCharsBase(c) || isDigit(c) ? ch : `_${c.toString(16)}_`;\n  }).join('')}`;\n};\n\n/**\n * Formats an IRI as a canonical `IRIREF`.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatIri = (iri: string): string => `<${Term.escapeIri(iri)}>`;\n\n/**\n * Formats a literal in canonical N-Triples form: canonical string escapes,\n * lower-case language tags, and no datatype for `xsd:string`.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatLiteral = (literal: Term.Literal): string => {\n  const lexical = `\"${Term.escapeString(literal.value)}\"`;\n  if (literal.language !== '') {\n    const language = literal.language.toLowerCase();\n    return literal.direction === undefined\n      ? `${lexical}@${language}`\n      : `${lexical}@${language}--${literal.direction}`;\n  }\n  if (literal.datatype.value === XSD_STRING) return lexical;\n  return `${lexical}^^${formatIri(literal.datatype.value)}`;\n};\n\n// Built once: `formatTerm` runs for every term a serializer writes.\nconst formatTermMatch = Match.type<Term.Term>().pipe(\n  Match.tag('NamedNode', (term) => formatIri(term.value)),\n  Match.tag('BlankNode', (term) => `_:${blankNodeLabel(term.value)}`),\n  Match.tag('Literal', (term) => formatLiteral(term)),\n  Match.tag('Triple', (term) => {\n    const s = formatTerm(term.subject);\n    const o = formatTerm(term.object);\n    return s === undefined || o === undefined\n      ? undefined\n      : `<<( ${s} ${formatIri(term.predicate.value)} ${o} )>>`;\n  }),\n  Match.orElse(() => undefined),\n);\n\n/**\n * Formats a ground term (IRI, blank node, literal or triple term) in\n * canonical N-Triples form. Returns `undefined` for variables and the\n * default graph, which have no N-Triples representation.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatTerm = (term: Term.Term): string | undefined => formatTermMatch(term);\n"],"mappings":"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"}

package/dist/Lexical-D3zySYVS.d.mts

@@ -0,0 +1,163 @@
+import { T as Term, d as NamedNode, i as Direction, l as Literal } from "./Term-B_4ezyXq.mjs";
+declare namespace Lexical_d_exports {
+  export { DecodedEscape, LanguageTag, blankNodeLabel, decodeEchar, decodeUchar, formatIri, formatLiteral, formatTerm, isAbsoluteIri, isBlankNodeLabel, isDigit, isHex, isIriChar, isPnChars, isPnCharsBase, isPnCharsU, isWritableIri, makeLiteral, parseLanguageTag };
+}
+/**
+ * `PN_CHARS_BASE` from the Turtle / N-Triples grammars.
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isPnCharsBase: (c: number) => boolean;
+/**
+ * `PN_CHARS_U`: `PN_CHARS_BASE` or `_`.
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isPnCharsU: (c: number) => boolean;
+/**
+ * `PN_CHARS`: `PN_CHARS_U`, `-`, digits, `·` and combining marks.
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isPnChars: (c: number) => boolean;
+/**
+ * Whether a code point is an ASCII digit.
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isDigit: (c: number) => boolean;
+/**
+ * Whether a code point is an ASCII hexadecimal digit.
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isHex: (c: number) => boolean;
+/**
+ * Whether a code point may appear unescaped inside an `IRIREF`
+ * (`[^#x00-#x20<>"{}|^`\]`).
+ *
+ * @since 0.1.0
+ * @category character classes
+ */
+declare const isIriChar: (c: number) => boolean;
+/**
+ * Whether a string is an absolute IRI reference (starts with a scheme).
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const isAbsoluteIri: (iri: string) => boolean;
+/**
+ * Whether an IRI can be written as an N-Triples / Turtle `IRIREF`: it is
+ * absolute and contains no characters that would need escaping.
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const isWritableIri: (iri: string) => boolean;
+/**
+ * Whether a string is a valid `BLANK_NODE_LABEL` (without the `_:`).
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const isBlankNodeLabel: (label: string) => boolean;
+/**
+ * The result of decoding a numeric escape: the code point or an error
+ * message.
+ *
+ * @since 0.1.0
+ * @category escapes
+ */
+type DecodedEscape = {
+  readonly _tag: 'Ok';
+  readonly value: string;
+  readonly length: number;
+} | {
+  readonly _tag: 'Error';
+  readonly message: string;
+};
+/**
+ * Decodes a `UCHAR` (`\uXXXX` or `\UXXXXXXXX`) starting at `index`, which
+ * must point at the backslash. Surrogate code points and values beyond
+ * U+10FFFF are rejected.
+ *
+ * @since 0.1.0
+ * @category escapes
+ */
+declare const decodeUchar: (input: string, index: number) => DecodedEscape;
+/**
+ * Decodes the string-escape (`ECHAR`) character following a backslash, if
+ * it is one of `t b n r f " ' \`.
+ *
+ * @since 0.1.0
+ * @category escapes
+ */
+declare const decodeEchar: (c: number) => string | undefined;
+/**
+ * A language tag with an optional base direction.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface LanguageTag {
+  readonly language: string;
+  readonly direction: Direction | undefined;
+}
+/**
+ * Parses the text of a `LANG_DIR` token (without the leading `@`). Returns
+ * `undefined` when the tag or direction is invalid; directions must be
+ * `ltr` or `rtl`.
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const parseLanguageTag: (text: string) => LanguageTag | undefined;
+/**
+ * Builds a literal from a lexical form and an optional language tag or
+ * datatype, rejecting the language-string datatypes used without a tag.
+ * Returns an error message on failure.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeLiteral: (value: string, annotation: LanguageTag | NamedNode | undefined) => Literal | string;
+/**
+ * Encodes an arbitrary blank node label as a valid N-Triples label. Valid
+ * labels are returned unchanged.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const blankNodeLabel: (label: string) => string;
+/**
+ * Formats an IRI as a canonical `IRIREF`.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatIri: (iri: string) => string;
+/**
+ * Formats a literal in canonical N-Triples form: canonical string escapes,
+ * lower-case language tags, and no datatype for `xsd:string`.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatLiteral: (literal: Literal) => string;
+/**
+ * Formats a ground term (IRI, blank node, literal or triple term) in
+ * canonical N-Triples form. Returns `undefined` for variables and the
+ * default graph, which have no N-Triples representation.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatTerm: (term: Term) => string | undefined;
+export { isPnCharsU as _, decodeEchar as a, parseLanguageTag as b, formatLiteral as c, isBlankNodeLabel as d, isDigit as f, isPnCharsBase as g, isPnChars as h, blankNodeLabel as i, formatTerm as l, isIriChar as m, LanguageTag as n, decodeUchar as o, isHex as p, Lexical_d_exports as r, formatIri as s, DecodedEscape as t, isAbsoluteIri as u, isWritableIri as v, makeLiteral as y };
+//# sourceMappingURL=Lexical-D3zySYVS.d.mts.map

package/dist/Manifest-B6xf6mUc.mjs

@@ -0,0 +1,148 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, U as isResource, Z as namedNode, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { A as objectsOf, C as list, L as subjectsOf, O as objectOf } from "./Dataset-BlmlcI7J.mjs";
+import { n as make, r as vocabulary } from "./Namespace-DHFIsORd.mjs";
+import { a as rdfs, i as rdf } from "./Vocab-DceKywpq.mjs";
+import { i as parse$1 } from "./Turtle-CZVUOtwl.mjs";
+import * as Arr from "effect/Array";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+// src/turtle/Manifest.ts
+/**
+* A reader for W3C test-suite manifests (`manifest.ttl`) as used by the RDF,
+* SPARQL, SHACL, ShEx and JSON-LD test suites.
+*
+* Manifests are parsed with the Turtle parser. `load` follows `mf:include`
+* recursively; reading files is delegated to a caller-supplied function so
+* that the module stays platform independent.
+*
+* @example
+* ```ts
+* import * as fs from 'node:fs'
+* import { Effect } from 'effect'
+* import { Manifest } from '@thomasfosterau/effect-rdf/turtle'
+*
+* const entries = Manifest.load(
+*   'https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/manifest.ttl',
+*   Manifest.fileReader('https://w3c.github.io/rdf-tests/', '/path/to/rdf-tests/', (path) =>
+*     Effect.sync(() => fs.readFileSync(path, 'utf8')),
+*   ),
+* )
+* ```
+*
+* @since 0.1.0
+*/
+var Manifest_exports = /* @__PURE__ */ __exportAll({
+	fileReader: () => fileReader,
+	load: () => load,
+	mf: () => mf,
+	parse: () => parse,
+	rdft: () => rdft,
+	toPath: () => toPath
+});
+/**
+* The W3C test manifest vocabulary.
+*
+* @since 0.1.0
+* @category vocabularies
+*/
+const mf = vocabulary("http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#", [
+	"Manifest",
+	"entries",
+	"include",
+	"name",
+	"action",
+	"result",
+	"assumedTestBase"
+]);
+/**
+* The RDF test vocabulary.
+*
+* @since 0.1.0
+* @category vocabularies
+*/
+const rdft = make("http://www.w3.org/ns/rdftest#");
+const localName = (iri) => iri.replace(/^.*[#/]/, "");
+const iriOf = (term) => Option.flatMap(term, (t) => isNamedNode(t) ? Option.some(t.value) : Option.none());
+const stringOf = (term) => Option.flatMap(term, (t) => isLiteral(t) ? Option.some(t.value) : Option.none());
+/**
+* Parses a manifest document. `iri` is the manifest's own IRI, used as the
+* base IRI.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (text, iri) => Effect.map(parse$1(text, { baseIri: iri }), ({ dataset }) => {
+	const subjects = subjectsOf(dataset, rdf.type, mf.Manifest);
+	const manifest = subjects.find((s) => isNamedNode(s) && s.value === iri) ?? subjects[0] ?? namedNode(iri);
+	const listAt = (p) => objectsOf(dataset, manifest, p).flatMap((head) => Option.getOrElse(list(dataset, head), () => []));
+	const entries = listAt(mf.entries).flatMap((node) => {
+		if (!isResource(node)) return [];
+		const type = iriOf(objectOf(dataset, node, rdf.type));
+		const id = isNamedNode(node) ? node.value : node.key;
+		return [{
+			id,
+			node,
+			type: Option.getOrElse(type, () => ""),
+			kind: Option.match(type, {
+				onNone: () => "",
+				onSome: localName
+			}),
+			name: Option.getOrElse(stringOf(objectOf(dataset, node, mf.name)), () => localName(id)),
+			comment: stringOf(objectOf(dataset, node, rdfs.comment)),
+			action: iriOf(objectOf(dataset, node, mf.action)),
+			result: iriOf(objectOf(dataset, node, mf.result)),
+			manifest: iri,
+			dataset
+		}];
+	});
+	return {
+		iri,
+		label: stringOf(objectOf(dataset, manifest, rdfs.label)),
+		assumedTestBase: iriOf(objectOf(dataset, manifest, mf.assumedTestBase)),
+		entries,
+		includes: listAt(mf.include).flatMap((t) => isNamedNode(t) ? [t.value] : []),
+		dataset
+	};
+});
+/**
+* Loads a manifest and, recursively, every manifest it includes, returning
+* all entries (each manifest is read at most once).
+*
+* @since 0.1.0
+* @category loading
+*/
+const load = (iri, read) => Effect.suspend(() => {
+	const seen = MutableHashSet.empty();
+	const entries = [];
+	const visit = (queue) => {
+		if (!Arr.isReadonlyArrayNonEmpty(queue)) return Effect.succeed(entries);
+		const [next, ...rest] = queue;
+		if (MutableHashSet.has(seen, next)) return visit(rest);
+		MutableHashSet.add(seen, next);
+		return read(next).pipe(Effect.flatMap((text) => parse(text, next)), Effect.flatMap((manifest) => {
+			entries.push(...manifest.entries);
+			return visit([...rest, ...manifest.includes]);
+		}));
+	};
+	return visit([iri]);
+});
+/**
+* Builds a `read` function for `load` that maps IRIs under `iriPrefix` to
+* paths under `pathPrefix` and reads them with `readFile`.
+*
+* @since 0.1.0
+* @category loading
+*/
+const fileReader = (iriPrefix, pathPrefix, readFile) => (iri) => readFile(toPath(iri, iriPrefix, pathPrefix));
+/**
+* Maps an IRI under `iriPrefix` to a path under `pathPrefix`.
+*
+* @since 0.1.0
+* @category loading
+*/
+const toPath = (iri, iriPrefix, pathPrefix) => iri.startsWith(iriPrefix) ? pathPrefix + iri.slice(iriPrefix.length) : iri;
+export { parse as a, mf as i, fileReader as n, rdft as o, load as r, toPath as s, Manifest_exports as t };
+
+//# sourceMappingURL=Manifest-B6xf6mUc.mjs.map

package/dist/Manifest-B6xf6mUc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manifest-B6xf6mUc.mjs","names":["Namespace.vocabulary","Namespace.make","Term.isNamedNode","Term.isLiteral","Turtle.parse","Dataset.subjectsOf","Term.namedNode","Dataset.objectsOf","Dataset.list","Term.isResource","Dataset.objectOf"],"sources":["../src/turtle/Manifest.ts"],"sourcesContent":["/**\n * A reader for W3C test-suite manifests (`manifest.ttl`) as used by the RDF,\n * SPARQL, SHACL, ShEx and JSON-LD test suites.\n *\n * Manifests are parsed with the Turtle parser. `load` follows `mf:include`\n * recursively; reading files is delegated to a caller-supplied function so\n * that the module stays platform independent.\n *\n * @example\n * ```ts\n * import * as fs from 'node:fs'\n * import { Effect } from 'effect'\n * import { Manifest } from '@thomasfosterau/effect-rdf/turtle'\n *\n * const entries = Manifest.load(\n *   'https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/manifest.ttl',\n *   Manifest.fileReader('https://w3c.github.io/rdf-tests/', '/path/to/rdf-tests/', (path) =>\n *     Effect.sync(() => fs.readFileSync(path, 'utf8')),\n *   ),\n * )\n * ```\n *\n * @since 0.1.0\n */\nimport * as Dataset from '../Dataset.ts';\nimport * as Namespace from '../Namespace.ts';\nimport type * as Serialization from '../Serialization.ts';\nimport * as Term from '../Term.ts';\nimport { rdf, rdfs } from '../Vocab.ts';\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Turtle from './Turtle.ts';\n\n/**\n * The W3C test manifest vocabulary.\n *\n * @since 0.1.0\n * @category vocabularies\n */\nexport const mf = Namespace.vocabulary(\n  'http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#',\n  ['Manifest', 'entries', 'include', 'name', 'action', 'result', 'assumedTestBase'],\n);\n\n/**\n * The RDF test vocabulary.\n *\n * @since 0.1.0\n * @category vocabularies\n */\nexport const rdft = Namespace.make('http://www.w3.org/ns/rdftest#');\n\n/**\n * A single test entry.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Entry {\n  /** The test IRI (or blank node key). */\n  readonly id: string;\n  /** The test node itself, for reading further properties from `dataset`. */\n  readonly node: Term.Subject;\n  /** The IRI of the test's `rdf:type`. */\n  readonly type: string;\n  /** The local name of the test type, e.g. `TestTurtleEval`. */\n  readonly kind: string;\n  /** `mf:name` (falls back to the local name of the test IRI). */\n  readonly name: string;\n  /** `rdfs:comment`, if any. */\n  readonly comment: Option.Option<string>;\n  /** The `mf:action` IRI, if the action is an IRI. */\n  readonly action: Option.Option<string>;\n  /** The `mf:result` IRI, if the result is an IRI. */\n  readonly result: Option.Option<string>;\n  /** The IRI of the manifest that lists this entry. */\n  readonly manifest: string;\n  /** The parsed manifest document. */\n  readonly dataset: Dataset.Dataset;\n}\n\n/**\n * A parsed manifest.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Manifest {\n  readonly iri: string;\n  readonly label: Option.Option<string>;\n  readonly assumedTestBase: Option.Option<string>;\n  readonly entries: ReadonlyArray<Entry>;\n  readonly includes: ReadonlyArray<string>;\n  readonly dataset: Dataset.Dataset;\n}\n\nconst localName = (iri: string): string => iri.replace(/^.*[#/]/, '');\n\nconst iriOf = (term: Option.Option<Term.Object>): Option.Option<string> =>\n  Option.flatMap(term, (t) => (Term.isNamedNode(t) ? Option.some(t.value) : Option.none()));\n\nconst stringOf = (term: Option.Option<Term.Object>): Option.Option<string> =>\n  Option.flatMap(term, (t) => (Term.isLiteral(t) ? Option.some(t.value) : Option.none()));\n\n/**\n * Parses a manifest document. `iri` is the manifest's own IRI, used as the\n * base IRI.\n *\n * @since 0.1.0\n * @category parsing\n */\nexport const parse = (\n  text: string,\n  iri: string,\n): Effect.Effect<Manifest, Serialization.RdfParseError> =>\n  Effect.map(Turtle.parse(text, { baseIri: iri }), ({ dataset }) => {\n    const subjects = Dataset.subjectsOf(dataset, rdf.type, mf.Manifest);\n    const manifest: Term.Subject =\n      subjects.find((s) => Term.isNamedNode(s) && s.value === iri) ??\n      subjects[0] ??\n      Term.namedNode(iri);\n    const listAt = (p: Term.NamedNode): ReadonlyArray<Term.Object> =>\n      Dataset.objectsOf(dataset, manifest, p).flatMap((head) =>\n        Option.getOrElse(Dataset.list(dataset, head), () => []),\n      );\n    const entries = listAt(mf.entries).flatMap((node): ReadonlyArray<Entry> => {\n      if (!Term.isResource(node)) return [];\n      const type = iriOf(Dataset.objectOf(dataset, node, rdf.type));\n      const id = Term.isNamedNode(node) ? node.value : node.key;\n      return [\n        {\n          id,\n          node,\n          type: Option.getOrElse(type, () => ''),\n          kind: Option.match(type, { onNone: () => '', onSome: localName }),\n          name: Option.getOrElse(stringOf(Dataset.objectOf(dataset, node, mf.name)), () =>\n            localName(id),\n          ),\n          comment: stringOf(Dataset.objectOf(dataset, node, rdfs.comment)),\n          action: iriOf(Dataset.objectOf(dataset, node, mf.action)),\n          result: iriOf(Dataset.objectOf(dataset, node, mf.result)),\n          manifest: iri,\n          dataset,\n        },\n      ];\n    });\n    return {\n      iri,\n      label: stringOf(Dataset.objectOf(dataset, manifest, rdfs.label)),\n      assumedTestBase: iriOf(Dataset.objectOf(dataset, manifest, mf.assumedTestBase)),\n      entries,\n      includes: listAt(mf.include).flatMap((t) => (Term.isNamedNode(t) ? [t.value] : [])),\n      dataset,\n    };\n  });\n\n/**\n * Loads a manifest and, recursively, every manifest it includes, returning\n * all entries (each manifest is read at most once).\n *\n * @since 0.1.0\n * @category loading\n */\nexport const load = <E, R>(\n  iri: string,\n  read: (iri: string) => Effect.Effect<string, E, R>,\n): Effect.Effect<ReadonlyArray<Entry>, E | Serialization.RdfParseError, R> =>\n  Effect.suspend(() => {\n    const seen = MutableHashSet.empty<string>();\n    const entries: Array<Entry> = [];\n    // Breadth first: a manifest's entries, then those of each include in turn\n    const visit = (\n      queue: ReadonlyArray<string>,\n    ): Effect.Effect<ReadonlyArray<Entry>, E | Serialization.RdfParseError, R> => {\n      if (!Arr.isReadonlyArrayNonEmpty(queue)) return Effect.succeed(entries);\n      const [next, ...rest] = queue;\n      if (MutableHashSet.has(seen, next)) return visit(rest);\n      MutableHashSet.add(seen, next);\n      return read(next).pipe(\n        Effect.flatMap((text) => parse(text, next)),\n        Effect.flatMap((manifest) => {\n          entries.push(...manifest.entries);\n          return visit([...rest, ...manifest.includes]);\n        }),\n      );\n    };\n    return visit([iri]);\n  });\n\n/**\n * Builds a `read` function for `load` that maps IRIs under `iriPrefix` to\n * paths under `pathPrefix` and reads them with `readFile`.\n *\n * @since 0.1.0\n * @category loading\n */\nexport const fileReader =\n  <E, R>(\n    iriPrefix: string,\n    pathPrefix: string,\n    readFile: (path: string) => Effect.Effect<string, E, R>,\n  ) =>\n  (iri: string): Effect.Effect<string, E, R> =>\n    readFile(toPath(iri, iriPrefix, pathPrefix));\n\n/**\n * Maps an IRI under `iriPrefix` to a path under `pathPrefix`.\n *\n * @since 0.1.0\n * @category loading\n */\nexport const toPath = (iri: string, iriPrefix: string, pathPrefix: string): string =>\n  iri.startsWith(iriPrefix) ? pathPrefix + iri.slice(iriPrefix.length) : iri;\n"],"mappings":"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"}