@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Term-CFLG1qu4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Term-CFLG1qu4.mjs","names":["XSD","NamedNode","BlankNode","Literal","Triple","Variable","DefaultGraph","Quad","TermJson.NamedNodeSchema","Generate","TermJson.BlankNodeSchema","TermJson.LiteralSchema","TermJson.VariableSchema","TermJson.TripleSchema","TermJson.QuadSchema","TermJson.TermSchema","TermJson.GroundTermSchema"],"sources":["../src/internal/arbitrary.ts","../src/Term.ts"],"sourcesContent":["/**\n * Generation representations for the term declarations' `toCodecArbitrary`\n * hooks: `TermJson`-shaped schemas whose native arbitraries produce realistic\n * values — IRIs from a small pool (so values collide across quads), BCP 47\n * language tags, both base directions, well-formed lexical forms for common\n * XSD datatypes, and triple terms nested at most two deep. Generated data is\n * RDF 1.2: triple terms appear only in the object position (of a quad or of\n * another triple term), never as subjects, as RDF 1.2 Concepts requires.\n *\n * Plain data only (no `Term` import), so `Term` can link to it without a\n * cycle; `Term` decodes these with `fromJson` and checks the result.\n */\nimport * as Schema from 'effect/Schema';\nimport type * as TermJson from '../TermJson.ts';\n\nconst XSD = 'http://www.w3.org/2001/XMLSchema#';\n\nconst NAMESPACES = [\n  'http://example.org/',\n  'http://example.org/vocab#',\n  'https://example.com/a/b/',\n  'urn:example:',\n];\nconst LOCAL_NAMES = ['a', 'b', 'c', 'knows', 'name', 'Thing', 'x-1', 'é'];\n\n/** The IRI pool: every namespace × local name. */\nconst IRIS = NAMESPACES.flatMap((ns) => LOCAL_NAMES.map((local) => `${ns}${local}`));\n\nconst pattern = (re: RegExp): Schema.String => Schema.String.check(Schema.isPattern(re));\n\nconst NamedNode: Schema.Codec<TermJson.NamedNode> = Schema.Struct({\n  type: Schema.Literal('uri'),\n  value: Schema.Literals(IRIS),\n});\n\nconst BlankNode: Schema.Codec<TermJson.BlankNode> = Schema.Struct({\n  type: Schema.Literal('bnode'),\n  value: Schema.Literals(['b0', 'b1', 'b2', 'b3', 'node']),\n});\n\nconst LANGUAGES = Schema.Literals([\n  'en',\n  'en-gb',\n  'fr',\n  'de-ch-1901',\n  'ar',\n  'zh-hant-tw',\n  'x-private',\n]);\n\nconst typedLiteral = (local: string, value: Schema.Codec<string>) =>\n  Schema.Struct({\n    type: Schema.Literal('literal'),\n    value,\n    datatype: Schema.Literal(`${XSD}${local}`),\n  });\n\nconst DATE = '(19|20)[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-8])';\n\nconst Literal: Schema.Codec<TermJson.Literal> = Schema.Union([\n  Schema.Struct({\n    type: Schema.Literal('literal'),\n    value: Schema.String.check(Schema.isMaxLength(8)),\n  }),\n  Schema.Struct({\n    type: Schema.Literal('literal'),\n    value: Schema.Literals(['', 'a', 'Alice', 'hello world', 'ünïcödé']),\n    'xml:lang': LANGUAGES,\n  }),\n  Schema.Struct({\n    type: Schema.Literal('literal'),\n    value: Schema.Literals(['a', 'שלום', 'مرحبا']),\n    'xml:lang': LANGUAGES,\n    'its:dir': Schema.Literals(['ltr', 'rtl']),\n  }),\n  typedLiteral('integer', pattern(/^-?(0|[1-9][0-9]{0,5})$/)),\n  typedLiteral('decimal', pattern(/^-?(0|[1-9][0-9]{0,3})\\.[0-9]{1,3}$/)),\n  typedLiteral('double', pattern(/^-?[1-9]\\.[0-9]{1,3}E-?[0-9]$/)),\n  typedLiteral('boolean', Schema.Literals(['true', 'false'])),\n  typedLiteral('date', pattern(new RegExp(`^${DATE}$`))),\n  typedLiteral(\n    'dateTime',\n    pattern(new RegExp(`^${DATE}T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](Z|[+-]0[0-9]:00)?$`)),\n  ),\n]);\n\nconst Resource = Schema.Union([NamedNode, BlankNode]);\n\nconst tripleOf = (object: Schema.Codec<TermJson.GroundTerm>): Schema.Codec<TermJson.Triple> =>\n  Schema.Struct({\n    type: Schema.Literal('triple'),\n    value: Schema.Struct({ subject: Resource, predicate: NamedNode, object }),\n  });\n\n// Depth one: no triple term inside; depth two: a triple term as the object.\nconst Triple1 = tripleOf(Schema.Union([NamedNode, BlankNode, Literal]));\n\nconst Triple: Schema.Codec<TermJson.Triple> = tripleOf(\n  Schema.Union([NamedNode, BlankNode, Literal, Triple1]),\n);\n\nconst Variable: Schema.Codec<TermJson.Variable> = Schema.Struct({\n  type: Schema.Literal('variable'),\n  value: Schema.Literals(['s', 'p', 'o', 'x']),\n});\n\nconst DefaultGraph: Schema.Codec<TermJson.DefaultGraph> = Schema.Struct({\n  type: Schema.Literal('default-graph'),\n});\n\nconst GroundTerm: Schema.Codec<TermJson.GroundTerm> = Schema.Union([\n  NamedNode,\n  BlankNode,\n  Literal,\n  Triple,\n]);\n\nconst Term: Schema.Codec<TermJson.Term> = Schema.Union([\n  NamedNode,\n  BlankNode,\n  Literal,\n  Triple,\n  Variable,\n  DefaultGraph,\n]);\n\nconst Quad: Schema.Codec<TermJson.Quad> = Schema.Struct({\n  subject: Resource,\n  predicate: NamedNode,\n  object: GroundTerm,\n  graph: Schema.optionalKey(Resource),\n});\n\n/** The representation each term declaration's `toCodecArbitrary` links to. */\nexport const representations = {\n  NamedNode,\n  BlankNode,\n  Literal,\n  Triple,\n  Variable,\n  DefaultGraph,\n  GroundTerm,\n  Term,\n  Quad,\n} as const;\n\n/** The most quads a generated dataset holds. */\nexport const MAX_DATASET_SIZE = 12;\n","/**\n * The RDF 1.2 term model.\n *\n * Terms are immutable values that implement Effect's `Equal` and `Hash`\n * protocols, so they can be used directly as keys of `HashMap`/`HashSet` and\n * compared with `Equal.equals`. Every term carries a canonical `key` — its\n * N-Triples / N-Quads serialisation — which is also what `toString()` returns.\n *\n * The model supports RDF 1.2 (and RDF-star) triple terms, directional\n * language-tagged strings, and SPARQL variables (used only in patterns).\n *\n * @since 0.1.0\n */\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as equivalence from 'effect/Equivalence';\nimport * as Hash from 'effect/Hash';\nimport { NodeInspectSymbol } from 'effect/Inspectable';\nimport * as Match from 'effect/Match';\nimport * as order from 'effect/Order';\nimport { pipeArguments, type Pipeable } from 'effect/Pipeable';\nimport { hasProperty, isString, isTagged } from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaIssue from 'effect/SchemaIssue';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport type * as SchemaAST from 'effect/SchemaAST';\nimport * as TermJson from './TermJson.ts';\nimport { representations as Generate } from './internal/arbitrary.ts';\n\nconst RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';\nconst XSD = 'http://www.w3.org/2001/XMLSchema#';\n\n/**\n * @since 0.1.0\n * @category symbols\n */\nexport const TypeId: unique symbol = Symbol.for('@thomasfosterau/effect-rdf/Term');\n\n/**\n * @since 0.1.0\n * @category symbols\n */\nexport type TypeId = typeof TypeId;\n\n/**\n * The base direction of a directional language-tagged string.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Direction = 'ltr' | 'rtl';\n\n/** `isTerm` for a value already known to be an object. */\nconst hasTermTypeId = (u: Equal.Equal): u is Term => TypeId in u;\n\n/** Mixed into the hashes of blank nodes and variables, so that `_:a` and `?a` differ from `<a>`. */\nconst BLANK_SALT = 0x5f3a;\nconst VARIABLE_SALT = 0x3f;\n\nabstract class TermBase implements Equal.Equal, Pipeable {\n  readonly [TypeId]: TypeId = TypeId;\n  abstract readonly _tag: string;\n  // Computed on first use. `''` stands for \"not yet\": only the default graph has the empty key,\n  // and computing it again is free. (A flag rather than a `NaN` hash, which would be a boxed\n  // number in every term.)\n  #key = '';\n  #hash = 0;\n  #hashed = false;\n\n  /** The canonical N-Triples serialisation of this term. */\n  get key(): string {\n    if (this.#key === '') this.#key = this.computeKey();\n    return this.#key;\n  }\n\n  protected abstract computeKey(): string;\n\n  /** RDF/JS compatible alias of `_tag`. */\n  get termType(): this['_tag'] {\n    return this._tag;\n  }\n\n  /** RDF/JS compatible equality. */\n  equals(that: unknown): boolean {\n    return isTerm(that) && that.key === this.key;\n  }\n\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return hasTermTypeId(that) && that.key === this.key;\n  }\n\n  [Hash.symbol](): number {\n    if (!this.#hashed) {\n      this.#hash = this.computeHash();\n      this.#hashed = true;\n    }\n    return this.#hash;\n  }\n\n  /**\n   * The hash, consistent with `key` (terms with equal keys have equal\n   * hashes). IRIs, blank nodes, variables and literals hash their parts, so\n   * that hashing one builds no key.\n   */\n  protected computeHash(): number {\n    return Hash.string(this.key);\n  }\n\n  pipe() {\n    return pipeArguments(this, arguments);\n  }\n\n  toString(): string {\n    return this.key;\n  }\n\n  toJSON() {\n    return { _tag: this._tag, value: this.key };\n  }\n\n  [NodeInspectSymbol](): string {\n    return `${this._tag}(${this.key})`;\n  }\n}\n\n/**\n * An IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport class NamedNode<out Iri extends string = string> extends TermBase {\n  readonly _tag = 'NamedNode' as const;\n  readonly value: Iri;\n  constructor(value: Iri) {\n    super();\n    this.value = value;\n  }\n  protected computeKey(): string {\n    return `<${escapeIri(this.value)}>`;\n  }\n  protected override computeHash(): number {\n    return Hash.string(this.value);\n  }\n}\n\n/**\n * A blank node. Labels are scoped to the dataset or document that contains\n * them.\n *\n * @since 0.1.0\n * @category models\n */\nexport class BlankNode extends TermBase {\n  readonly _tag = 'BlankNode' as const;\n  readonly value: string;\n  constructor(value: string) {\n    super();\n    this.value = value;\n  }\n  protected computeKey(): string {\n    return `_:${this.value}`;\n  }\n  protected override computeHash(): number {\n    return Hash.combine(Hash.string(this.value), BLANK_SALT);\n  }\n}\n\n/**\n * A literal. Language-tagged strings have datatype `rdf:langString`, and\n * directional language-tagged strings (RDF 1.2) have datatype\n * `rdf:dirLangString`.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Literal extends TermBase {\n  readonly _tag = 'Literal' as const;\n  readonly value: string;\n  readonly datatype: NamedNode;\n  readonly language: string;\n  readonly direction: Direction | undefined;\n  constructor(value: string, datatype: NamedNode, language: string = '', direction?: Direction) {\n    super();\n    this.value = value;\n    this.datatype = datatype;\n    this.language = language;\n    this.direction = direction;\n  }\n  protected computeKey(): string {\n    const lexical = `\"${escapeString(this.value)}\"`;\n    if (this.language !== '') {\n      return this.direction === undefined\n        ? `${lexical}@${this.language}`\n        : `${lexical}@${this.language}--${this.direction}`;\n    }\n    if (this.datatype.value === XSD_STRING) return lexical;\n    return `${lexical}^^${this.datatype.key}`;\n  }\n  protected override computeHash(): number {\n    const h = Hash.combine(Hash.string(this.value), this.datatype[Hash.symbol]());\n    return this.language === '' ? h : Hash.combine(h, Hash.string(this.language));\n  }\n}\n\n/**\n * A SPARQL query variable. Variables never appear in RDF data; they are used\n * in quad patterns.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Variable<out Name extends string = string> extends TermBase {\n  readonly _tag = 'Variable' as const;\n  readonly value: Name;\n  constructor(value: Name) {\n    super();\n    this.value = value;\n  }\n  protected computeKey(): string {\n    return `?${this.value}`;\n  }\n  protected override computeHash(): number {\n    return Hash.combine(Hash.string(this.value), VARIABLE_SALT);\n  }\n}\n\n/**\n * The default graph of a dataset.\n *\n * @since 0.1.0\n * @category models\n */\nexport class DefaultGraph extends TermBase {\n  readonly _tag = 'DefaultGraph' as const;\n  readonly value = '' as const;\n  protected computeKey(): string {\n    return '';\n  }\n}\n\n/**\n * An RDF triple. Triples are also terms (RDF 1.2 \"triple terms\", RDF-star\n * \"quoted triples\") and may appear in the subject or object position of\n * other triples.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Triple<\n  out S extends Subject = Subject,\n  out P extends Predicate = Predicate,\n  out O extends Object = Object,\n> extends TermBase {\n  readonly _tag = 'Triple' as const;\n  readonly subject: S;\n  readonly predicate: P;\n  readonly object: O;\n  constructor(subject: S, predicate: P, object: O) {\n    super();\n    this.subject = subject;\n    this.predicate = predicate;\n    this.object = object;\n  }\n  protected computeKey(): string {\n    return `<<( ${this.subject.key} ${this.predicate.key} ${this.object.key} )>>`;\n  }\n  /** Always the default graph: a triple term carries no graph name. */\n  get graph(): DefaultGraph {\n    return defaultGraph;\n  }\n}\n\n/**\n * An RDF quad: a triple together with the graph that contains it.\n *\n * `Quad` is a statement, not a term; use `Triple` for triple terms.\n *\n * @since 0.1.0\n * @category models\n */\nexport class Quad<\n  out S extends Subject = Subject,\n  out P extends Predicate = Predicate,\n  out O extends Object = Object,\n  out G extends Graph = Graph,\n>\n  implements Equal.Equal, Pipeable\n{\n  readonly _tag = 'Quad' as const;\n  // Computed on first use; `''` stands for \"not yet\" (no statement has an empty key).\n  #key = '';\n  #hash = 0;\n  #hashed = false;\n  readonly subject: S;\n  readonly predicate: P;\n  readonly object: O;\n  readonly graph: G;\n  constructor(subject: S, predicate: P, object: O, graph: G) {\n    this.subject = subject;\n    this.predicate = predicate;\n    this.object = object;\n    this.graph = graph;\n  }\n\n  /** The canonical N-Quads statement (without the trailing ` .`). */\n  get key(): string {\n    if (this.#key === '') {\n      const triple = `${this.subject.key} ${this.predicate.key} ${this.object.key}`;\n      this.#key = this.graph._tag === 'DefaultGraph' ? triple : `${triple} ${this.graph.key}`;\n    }\n    return this.#key;\n  }\n\n  /** The triple of this quad, without its graph. */\n  get triple(): Triple<S, P, O> {\n    return new Triple(this.subject, this.predicate, this.object);\n  }\n\n  equals(that: unknown): boolean {\n    return isQuad(that) && that.key === this.key;\n  }\n\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof Quad && that.key === this.key;\n  }\n\n  [Hash.symbol](): number {\n    if (!this.#hashed) {\n      this.#hash = Hash.string(this.key);\n      this.#hashed = true;\n    }\n    return this.#hash;\n  }\n\n  pipe() {\n    return pipeArguments(this, arguments);\n  }\n\n  toString(): string {\n    return `${this.key} .`;\n  }\n\n  toJSON() {\n    return { _tag: 'Quad' as const, value: this.toString() };\n  }\n\n  [NodeInspectSymbol](): string {\n    return `Quad(${this.key})`;\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Unions\n// -----------------------------------------------------------------------------\n\n/**\n * Any RDF term.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Term = NamedNode | BlankNode | Literal | Variable | DefaultGraph | Triple;\n\n/**\n * Terms allowed in the subject position of RDF data.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Subject = NamedNode | BlankNode | Triple;\n\n/**\n * Terms allowed in the predicate position of RDF data.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Predicate = NamedNode;\n\n/**\n * Terms allowed in the object position of RDF data.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Object = NamedNode | BlankNode | Literal | Triple;\n\n/**\n * Terms allowed as graph names.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Graph = NamedNode | BlankNode | DefaultGraph;\n\n/**\n * Ground terms: terms that may appear in RDF data (everything except\n * variables and the default graph marker).\n *\n * @since 0.1.0\n * @category models\n */\nexport type GroundTerm = NamedNode | BlankNode | Literal | Triple;\n\n/**\n * IRIs and blank nodes.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Resource = NamedNode | BlankNode;\n\n/**\n * A term or variable in a quad pattern.\n *\n * @since 0.1.0\n * @category models\n */\nexport type PatternTerm<T extends Term> = T | Variable;\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * The singleton default graph.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const defaultGraph: DefaultGraph = new DefaultGraph();\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const namedNode = <const Iri extends string>(iri: Iri): NamedNode<Iri> => new NamedNode(iri);\n\nlet blankNodeCounter = 0;\n\n/**\n * Creates a blank node. When no label is given a fresh, process-unique label\n * is generated.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const blankNode = (label?: string): BlankNode =>\n  new BlankNode(label ?? `b${(blankNodeCounter++).toString(36)}`);\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const variable = <const Name extends string>(name: Name): Variable<Name> =>\n  new Variable(name);\n\n/** @internal */\nexport const XSD_STRING = `${XSD}string`;\n/** @internal */\nexport const RDF_LANG_STRING = `${RDF}langString`;\n/** @internal */\nexport const RDF_DIR_LANG_STRING = `${RDF}dirLangString`;\n\nconst xsdString = new NamedNode(XSD_STRING);\nconst rdfLangString = new NamedNode(RDF_LANG_STRING);\nconst rdfDirLangString = new NamedNode(RDF_DIR_LANG_STRING);\n\n/**\n * Creates a literal.\n *\n * - `literal(\"x\")` is an `xsd:string`\n * - `literal(\"x\", \"en\")` is a language-tagged string\n * - `literal(\"x\", { language: \"ar\", direction: \"rtl\" })` is a directional\n *   language-tagged string\n * - `literal(\"1\", xsd.integer)` is a typed literal\n *\n * Language tags are normalised to lower case.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const literal = (\n  value: string,\n  languageOrDatatype?:\n    | string\n    | NamedNode\n    | { readonly language: string; readonly direction?: Direction | undefined },\n): Literal => {\n  if (languageOrDatatype === undefined) return new Literal(value, xsdString);\n  if (isString(languageOrDatatype)) {\n    return new Literal(value, rdfLangString, languageOrDatatype.toLowerCase());\n  }\n  if ('language' in languageOrDatatype) {\n    const language = languageOrDatatype.language.toLowerCase();\n    return languageOrDatatype.direction === undefined\n      ? new Literal(value, rdfLangString, language)\n      : new Literal(value, rdfDirLangString, language, languageOrDatatype.direction);\n  }\n  if (\n    languageOrDatatype.value === RDF_LANG_STRING ||\n    languageOrDatatype.value === RDF_DIR_LANG_STRING\n  ) {\n    // A language-tagged datatype without a language tag is invalid; keep the\n    // lexical form but fall back to a plain string.\n    return new Literal(value, xsdString);\n  }\n  return new Literal(value, languageOrDatatype);\n};\n\n/**\n * Creates a triple (and triple term).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const triple = <S extends Subject, P extends Predicate, O extends Object>(\n  subject: S,\n  predicate: P,\n  object: O,\n): Triple<S, P, O> => new Triple(subject, predicate, object);\n\n/**\n * Creates a quad. The graph defaults to the default graph.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport function quad<S extends Subject, P extends Predicate, O extends Object>(\n  subject: S,\n  predicate: P,\n  object: O,\n): Quad<S, P, O, DefaultGraph>;\nexport function quad<S extends Subject, P extends Predicate, O extends Object, G extends Graph>(\n  subject: S,\n  predicate: P,\n  object: O,\n  graph: G,\n): Quad<S, P, O, G>;\nexport function quad(\n  subject: Subject,\n  predicate: Predicate,\n  object: Object,\n  graph: Graph = defaultGraph,\n): Quad {\n  return new Quad(subject, predicate, object, graph);\n}\n\n/**\n * Converts a triple to a quad in the given graph (default graph when omitted).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const toQuad = <\n  S extends Subject,\n  P extends Predicate,\n  O extends Object,\n  G extends Graph = DefaultGraph,\n>(\n  self: Triple<S, P, O>,\n  graph?: G,\n): Quad<S, P, O, G> =>\n  // SAFETY: `G` defaults to the default graph type when no graph is given.\n  new Quad(self.subject, self.predicate, self.object, (graph ?? defaultGraph) as G);\n\n// -----------------------------------------------------------------------------\n// Guards\n// -----------------------------------------------------------------------------\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isTerm = (u: unknown): u is Term => hasProperty(u, TypeId);\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isNamedNode = (u: unknown): u is NamedNode => isTerm(u) && isTagged(u, 'NamedNode');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isBlankNode = (u: unknown): u is BlankNode => isTerm(u) && isTagged(u, 'BlankNode');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isLiteral = (u: unknown): u is Literal => isTerm(u) && isTagged(u, 'Literal');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isVariable = (u: unknown): u is Variable => isTerm(u) && isTagged(u, 'Variable');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isDefaultGraph = (u: unknown): u is DefaultGraph =>\n  isTerm(u) && isTagged(u, 'DefaultGraph');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isTriple = (u: unknown): u is Triple => isTerm(u) && isTagged(u, 'Triple');\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isQuad = (u: unknown): u is Quad => u instanceof Quad;\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isResource = (u: unknown): u is Resource => isNamedNode(u) || isBlankNode(u);\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isSubject = (u: unknown): u is Subject =>\n  isNamedNode(u) || isBlankNode(u) || isTriple(u);\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isObject = (u: unknown): u is Object =>\n  isNamedNode(u) || isBlankNode(u) || isLiteral(u) || isTriple(u);\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isGraph = (u: unknown): u is Graph =>\n  isNamedNode(u) || isBlankNode(u) || isDefaultGraph(u);\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isGroundTerm = (u: unknown): u is GroundTerm =>\n  isNamedNode(u) || isBlankNode(u) || isLiteral(u) || isTriple(u);\n\n/**\n * Whether a literal is a (possibly directional) language-tagged string.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isLanguageTagged = (self: Literal): boolean => self.language !== '';\n\n// Built once: `hasBlankNodes` runs for every term of every quad a dataset or comparison visits.\nconst blankNodesIn: (self: Term | Quad) => boolean = Match.type<Term | Quad>().pipe(\n  Match.tag('BlankNode', () => true),\n  Match.tag('Triple', (self) => hasBlankNodes(self.subject) || hasBlankNodes(self.object)),\n  Match.tag(\n    'Quad',\n    (self) =>\n      hasBlankNodes(self.subject) || hasBlankNodes(self.object) || hasBlankNodes(self.graph),\n  ),\n  Match.orElse(() => false),\n);\n\n/**\n * Whether a triple or quad mentions a blank node anywhere, including inside\n * nested triple terms.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const hasBlankNodes = (self: Term | Quad): boolean => blankNodesIn(self);\n\n// Built once: `isGround` runs for every term of every pattern or quad it checks.\nconst groundCheck: (self: Term | Quad) => boolean = Match.type<Term | Quad>().pipe(\n  Match.tag('Variable', () => false),\n  Match.tag(\n    'Triple',\n    (self) => isGround(self.subject) && isGround(self.predicate) && isGround(self.object),\n  ),\n  Match.tag(\n    'Quad',\n    (self) =>\n      isGround(self.subject) &&\n      isGround(self.predicate) &&\n      isGround(self.object) &&\n      isGround(self.graph),\n  ),\n  Match.orElse(() => true),\n);\n\n/**\n * Whether a term or quad is free of variables.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isGround = (self: Term | Quad): boolean => groundCheck(self);\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\n/**\n * Applies `f` to every term in a quad or triple term (recursively through\n * nested triple terms). `f` maps each term to one of the same kind; a\n * result that cannot stand in its position (a literal for a subject, say)\n * leaves the original term there.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport function mapTerms<T extends Quad | Triple>(\n  self: T,\n  f: (term: NamedNode | BlankNode | Literal | DefaultGraph) => Term,\n): T;\nexport function mapTerms(\n  self: Quad | Triple,\n  f: (term: NamedNode | BlankNode | Literal | DefaultGraph) => Term,\n): Quad | Triple {\n  // `f` is to map each leaf to a term of the same kind; a result that cannot stand in its\n  // position leaves the term there as it was. A statement whose terms all map to themselves is\n  // returned as it is (with its key, if computed).\n  const go = (term: Subject | Predicate | Object | Graph): Term =>\n    isTripleTerm(term) ? goTriple(term) : f(term);\n  const goTriple = (term: Triple): Triple => {\n    const s = subjectOr(go(term.subject), term.subject);\n    const p = predicateOr(go(term.predicate), term.predicate);\n    const o = objectOr(go(term.object), term.object);\n    return s === term.subject && p === term.predicate && o === term.object\n      ? term\n      : new Triple(s, p, o);\n  };\n  if (isTripleTerm(self)) return goTriple(self);\n  const s = subjectOr(go(self.subject), self.subject);\n  const p = predicateOr(go(self.predicate), self.predicate);\n  const o = objectOr(go(self.object), self.object);\n  const g = graphOr(go(self.graph), self.graph);\n  return s === self.subject && p === self.predicate && o === self.object && g === self.graph\n    ? self\n    : new Quad(s, p, o, g);\n}\n\nconst isTripleTerm = (t: Term | Quad): t is Triple => isTagged(t, 'Triple');\nconst isResourceTerm = (t: Term): t is Resource =>\n  isTagged(t, 'NamedNode') || isTagged(t, 'BlankNode');\nconst subjectOr = (t: Term, fallback: Subject): Subject =>\n  isResourceTerm(t) || isTripleTerm(t) ? t : fallback;\nconst predicateOr = (t: Term, fallback: Predicate): Predicate =>\n  isTagged(t, 'NamedNode') ? t : fallback;\nconst objectOr = (t: Term, fallback: Object): Object =>\n  isResourceTerm(t) || isTripleTerm(t) || isTagged(t, 'Literal') ? t : fallback;\nconst graphOr = (t: Term, fallback: Graph): Graph =>\n  isResourceTerm(t) || isTagged(t, 'DefaultGraph') ? t : fallback;\n\n/**\n * A total ordering of terms suitable for deterministic serialisation:\n * default graph < blank nodes < IRIs < literals < triple terms < variables,\n * then by canonical key.\n *\n * @since 0.1.0\n * @category ordering\n */\nexport const compare = (a: Term, b: Term): -1 | 0 | 1 => {\n  const ra = rank[a._tag];\n  const rb = rank[b._tag];\n  if (ra !== rb) return ra < rb ? -1 : 1;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n};\n\nconst rank: Record<Term['_tag'], number> = {\n  DefaultGraph: 0,\n  BlankNode: 1,\n  NamedNode: 2,\n  Literal: 3,\n  Triple: 4,\n  Variable: 5,\n};\n\n/**\n * Orders quads by graph, subject, predicate, object.\n *\n * @since 0.1.0\n * @category ordering\n */\nexport const compareQuads = (a: Quad, b: Quad): -1 | 0 | 1 =>\n  compare(a.graph, b.graph) ||\n  compare(a.subject, b.subject) ||\n  compare(a.predicate, b.predicate) ||\n  compare(a.object, b.object);\n\n/**\n * The `compare` ordering of terms as an Effect `Order`, for `Array.sort`,\n * `Order.mapInput` and the other `Order` combinators.\n *\n * @since 0.1.0\n * @category ordering\n */\nexport const Order: order.Order<Term> = order.make(compare);\n\n/**\n * The `compareQuads` ordering (graph, subject, predicate, object) as an\n * Effect `Order`.\n *\n * @since 0.1.0\n * @category ordering\n */\nexport const QuadOrder: order.Order<Quad> = order.make(compareQuads);\n\n/**\n * Term equality as an Effect `Equivalence`: the same as `Equal.equals`\n * (equal canonical keys).\n *\n * @since 0.1.0\n * @category equivalence\n */\nexport const Equivalence: equivalence.Equivalence<Term> = equivalence.make(\n  (a, b) => a.key === b.key,\n);\n\n/**\n * Quad equality as an Effect `Equivalence`: the same as `Equal.equals`.\n *\n * @since 0.1.0\n * @category equivalence\n */\nexport const QuadEquivalence: equivalence.Equivalence<Quad> = equivalence.make(\n  (a, b) => a.key === b.key,\n);\n\n// -----------------------------------------------------------------------------\n// Escaping\n// -----------------------------------------------------------------------------\n\n// Built once: `escapeString` runs it for every character of a string that needs escaping.\nconst escapeChar: (ch: string) => string = Match.type<string>().pipe(\n  Match.when('\"', () => '\\\\\"'),\n  Match.when('\\\\', () => '\\\\\\\\'),\n  Match.when('\\n', () => '\\\\n'),\n  Match.when('\\r', () => '\\\\r'),\n  Match.when('\\t', () => '\\\\t'),\n  Match.when('\\b', () => '\\\\b'),\n  Match.when('\\f', () => '\\\\f'),\n  Match.orElse((ch) => {\n    const code = ch.codePointAt(0) ?? 0;\n    return code < 0x20 || code === 0x7f || code === 0xfffe || code === 0xffff\n      ? `\\\\u${code.toString(16).toUpperCase().padStart(4, '0')}`\n      : ch;\n  }),\n);\n\n/**\n * Escapes a string for use inside a double-quoted N-Triples / Turtle string\n * literal, using the canonical N-Triples escapes.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const escapeString = (value: string): string => {\n  // eslint-disable-next-line no-control-regex\n  if (!/[\"\\\\\\u0000-\\u001f\\u007f\\ufffe\\uffff]/.test(value)) return value;\n  // By code point, as `for … of` iterates a string\n  return value.replace(/[\\s\\S]/gu, (ch) => escapeChar(ch));\n};\n\n// The characters an IRIREF cannot contain unescaped, hoisted so the hot\n// `NamedNode.key` path does not build a regex per call. `replace` resets the\n// global one's `lastIndex`, and `test` on the non-global one keeps no state.\n// eslint-disable-next-line no-control-regex\nconst IRI_UNSAFE = /[\\u0000- <>\"{}|^`\\\\]/;\n// eslint-disable-next-line no-control-regex\nconst IRI_UNSAFE_ALL = /[\\u0000- <>\"{}|^`\\\\]/g;\n\n/**\n * Escapes characters that are not allowed inside `<...>` IRI references.\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const escapeIri = (value: string): string =>\n  IRI_UNSAFE.test(value)\n    ? value.replace(\n        IRI_UNSAFE_ALL,\n        (ch) => `\\\\u${ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`,\n      )\n    : value;\n\n// -----------------------------------------------------------------------------\n// JSON\n// -----------------------------------------------------------------------------\n\nconst namedNodeToJson = (n: NamedNode): TermJson.NamedNode => ({ type: 'uri', value: n.value });\n\nconst blankNodeToJson = (b: BlankNode): TermJson.BlankNode => ({ type: 'bnode', value: b.value });\n\nconst resourceToJson: (r: Resource) => TermJson.NamedNode | TermJson.BlankNode =\n  Match.type<Resource>().pipe(\n    Match.tag('NamedNode', namedNodeToJson),\n    Match.tag('BlankNode', blankNodeToJson),\n    Match.exhaustive,\n  );\n\nconst literalToJson = (l: Literal): TermJson.Literal => {\n  if (l.language !== '') {\n    return l.direction === undefined\n      ? { type: 'literal', value: l.value, 'xml:lang': l.language }\n      : { type: 'literal', value: l.value, 'xml:lang': l.language, 'its:dir': l.direction };\n  }\n  return l.datatype.value === XSD_STRING\n    ? { type: 'literal', value: l.value }\n    : { type: 'literal', value: l.value, datatype: l.datatype.value };\n};\n\nconst tripleToJson = (x: Triple): TermJson.Triple => ({\n  type: 'triple',\n  value: {\n    subject: toJson(x.subject),\n    predicate: namedNodeToJson(x.predicate),\n    object: toJson(x.object),\n  },\n});\n\nconst variableToJson = (v: Variable): TermJson.Variable => ({ type: 'variable', value: v.value });\n\nconst defaultGraphToJson = (): TermJson.DefaultGraph => ({ type: 'default-graph' });\n\n// Built once: `toJson` runs for every term a JSON codec or SPARQL results writer encodes.\nconst groundToJson: (self: GroundTerm) => TermJson.GroundTerm = Match.type<GroundTerm>().pipe(\n  Match.tag('NamedNode', namedNodeToJson),\n  Match.tag('BlankNode', blankNodeToJson),\n  Match.tag('Literal', literalToJson),\n  Match.tag('Triple', tripleToJson),\n  Match.exhaustive,\n);\n\nconst termToJson: (self: Term) => TermJson.Term = Match.type<Term>().pipe(\n  Match.tag('Variable', variableToJson),\n  Match.tag('DefaultGraph', defaultGraphToJson),\n  Match.orElse(groundToJson),\n);\n\n/**\n * Encodes a term as JSON: the SPARQL 1.2 JSON results term for a ground term,\n * plus the `variable` and `default-graph` extensions (see `TermJson`).\n *\n * @since 0.1.0\n * @category json\n */\nexport function toJson(self: GroundTerm): TermJson.GroundTerm;\nexport function toJson(self: Term): TermJson.Term;\nexport function toJson(self: Term): TermJson.Term {\n  return termToJson(self);\n}\n\nconst literalFromJson = (l: TermJson.Literal): Literal => {\n  const lang = l['xml:lang'];\n  if (lang !== undefined && lang !== '') {\n    const dir = l['its:dir'];\n    return dir === 'ltr' || dir === 'rtl'\n      ? literal(l.value, { language: lang, direction: dir })\n      : literal(l.value, lang);\n  }\n  return l.datatype === undefined ? literal(l.value) : literal(l.value, namedNode(l.datatype));\n};\n\nconst tripleFromJson = (x: TermJson.Triple): Triple =>\n  // SAFETY: unchecked, as in SPARQL JSON results; `isWellFormed` (and the JSON codecs) check\n  // that the positions hold a subject, an IRI predicate and an object.\n  new Triple(\n    fromJson(x.value.subject) as Subject,\n    fromJson(x.value.predicate) as Predicate,\n    fromJson(x.value.object),\n  );\n\nconst groundFromJson: (json: TermJson.GroundTerm) => GroundTerm =\n  Match.type<TermJson.GroundTerm>().pipe(\n    Match.when({ type: 'uri' }, (u): GroundTerm => namedNode(u.value)),\n    Match.when({ type: 'bnode' }, (b): GroundTerm => blankNode(b.value)),\n    Match.when({ type: Match.is('literal', 'typed-literal') }, literalFromJson),\n    Match.when({ type: 'triple' }, tripleFromJson),\n    Match.exhaustive,\n  );\n\n// Built once: `fromJson` runs for every term of every JSON row it decodes.\nconst termFromJson: (json: TermJson.Term) => Term = Match.type<TermJson.Term>().pipe(\n  Match.when({ type: 'variable' }, (v): Term => variable(v.value)),\n  Match.when({ type: 'default-graph' }, (): Term => defaultGraph),\n  Match.orElse(groundFromJson),\n);\n\n/**\n * Decodes a JSON term (see `TermJson`). Like a SPARQL JSON results reader,\n * it trusts the positions of a triple term; use `isWellFormed`, or decode\n * through `Schema.toCodecJson(TermSchema)`, to check them.\n *\n * @since 0.1.0\n * @category json\n */\nexport function fromJson(json: TermJson.GroundTerm): GroundTerm;\nexport function fromJson(json: TermJson.Term): Term;\nexport function fromJson(json: TermJson.Term): Term {\n  return termFromJson(json);\n}\n\nconst subjectToJson: (s: Subject) => TermJson.Quad['subject'] = Match.type<Subject>().pipe(\n  Match.tag('Triple', tripleToJson),\n  Match.orElse(resourceToJson),\n);\n\n/**\n * Encodes a quad as JSON; `graph` is omitted for the default graph.\n *\n * @since 0.1.0\n * @category json\n */\nexport const quadToJson = (self: Quad): TermJson.Quad => {\n  const subject = subjectToJson(self.subject);\n  const predicate = namedNodeToJson(self.predicate);\n  const object = groundToJson(self.object);\n  return Match.value(self.graph).pipe(\n    Match.tag('DefaultGraph', (): TermJson.Quad => ({ subject, predicate, object })),\n    Match.orElse((graph): TermJson.Quad => ({\n      subject,\n      predicate,\n      object,\n      graph: resourceToJson(graph),\n    })),\n  );\n};\n\nconst resourceFromJson = (json: TermJson.NamedNode | TermJson.BlankNode): Resource =>\n  json.type === 'uri' ? namedNode(json.value) : blankNode(json.value);\n\n/**\n * Decodes a JSON quad; a missing `graph` is the default graph. Triple terms\n * are trusted as in `fromJson`.\n *\n * @since 0.1.0\n * @category json\n */\nexport const quadFromJson = (json: TermJson.Quad): Quad =>\n  new Quad(\n    json.subject.type === 'triple' ? tripleFromJson(json.subject) : resourceFromJson(json.subject),\n    namedNode(json.predicate.value),\n    groundFromJson(json.object),\n    json.graph === undefined ? defaultGraph : resourceFromJson(json.graph),\n  );\n\n/**\n * Whether every triple term inside a term or quad, at any depth, has a\n * subject (IRI, blank node or triple term), an IRI predicate and an object\n * (anything but a variable or the default graph) — always true for terms\n * built with `triple` and `quad`.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWellFormed = (self: Term | Quad): boolean => wellFormedCheck(self);\n\n// Built once: the JSON codecs run it on every term and quad they decode.\nconst wellFormedCheck: (self: Term | Quad) => boolean = Match.type<Term | Quad>().pipe(\n  Match.tag('Quad', (q) => isWellFormed(q.subject) && isWellFormed(q.object)),\n  Match.tag(\n    'Triple',\n    (x) =>\n      isSubject(x.subject) &&\n      isNamedNode(x.predicate) &&\n      isObject(x.object) &&\n      isWellFormed(x.subject) &&\n      isWellFormed(x.object),\n  ),\n  Match.orElse(() => true),\n);\n\n/**\n * The `toCodecJson` (and `toCodecArbitrary`) link of a term declaration, to a\n * `TermJson`-shaped schema: decodes through `fromJson` and fails unless the\n * result is the declared kind and well formed.\n */\nconst jsonLink =\n  <T extends Term, J extends TermJson.Term>(\n    json: Schema.Codec<J>,\n    is: (term: Term) => term is T,\n    encode: (term: T) => J,\n    expected: string,\n  ) =>\n  (): SchemaAST.Link =>\n    Schema.link<T>()(\n      json,\n      SchemaTransformation.transformEffect<T, J>({\n        decode: (j, options) => {\n          const term = fromJson(j);\n          return is(term) && isWellFormed(term)\n            ? Effect.succeed(term)\n            : Effect.fail(new SchemaIssue.InvalidValue({ expected }, j, options));\n        },\n        encode: (term) => Effect.succeed(encode(term)),\n      }),\n    );\n\n/** The `toCodecJson` / `toCodecArbitrary` link of `QuadSchema`. */\nconst quadLink = (json: Schema.Codec<TermJson.Quad>) => (): SchemaAST.Link =>\n  Schema.link<Quad>()(\n    json,\n    SchemaTransformation.transformEffect<Quad, TermJson.Quad>({\n      decode: (j, options) => {\n        const q = quadFromJson(j);\n        return isWellFormed(q)\n          ? Effect.succeed(q)\n          : Effect.fail(\n              new SchemaIssue.InvalidValue({ expected: 'a well-formed quad' }, j, options),\n            );\n      },\n      encode: (q) => Effect.succeed(quadToJson(q)),\n    }),\n  );\n\n// -----------------------------------------------------------------------------\n// Schemas\n// -----------------------------------------------------------------------------\n\n/**\n * Schema of an IRI term; its JSON codec is `TermJson.NamedNode`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const NamedNodeSchema: Schema.declare<NamedNode> = Schema.declare(isNamedNode, {\n  identifier: 'NamedNode',\n  toCodecJson: jsonLink(TermJson.NamedNodeSchema, isNamedNode, namedNodeToJson, 'an IRI'),\n  toCodecArbitrary: jsonLink(Generate.NamedNode, isNamedNode, namedNodeToJson, 'an IRI'),\n});\n\n/**\n * The type `NamedNodeSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type NamedNodeSchema = typeof NamedNodeSchema.Type;\n\n/**\n * Schema of a blank node; its JSON codec is `TermJson.BlankNode`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const BlankNodeSchema: Schema.declare<BlankNode> = Schema.declare(isBlankNode, {\n  identifier: 'BlankNode',\n  toCodecJson: jsonLink(TermJson.BlankNodeSchema, isBlankNode, blankNodeToJson, 'a blank node'),\n  toCodecArbitrary: jsonLink(Generate.BlankNode, isBlankNode, blankNodeToJson, 'a blank node'),\n});\n\n/**\n * The type `BlankNodeSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type BlankNodeSchema = typeof BlankNodeSchema.Type;\n\n/**\n * Schema of a literal; its JSON codec is `TermJson.Literal`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const LiteralSchema: Schema.declare<Literal> = Schema.declare(isLiteral, {\n  identifier: 'Literal',\n  toCodecJson: jsonLink(TermJson.LiteralSchema, isLiteral, literalToJson, 'a literal'),\n  toCodecArbitrary: jsonLink(Generate.Literal, isLiteral, literalToJson, 'a literal'),\n});\n\n/**\n * The type `LiteralSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type LiteralSchema = typeof LiteralSchema.Type;\n\n/**\n * Schema of a variable; its JSON codec is `TermJson.Variable`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const VariableSchema: Schema.declare<Variable> = Schema.declare(isVariable, {\n  identifier: 'Variable',\n  toCodecJson: jsonLink(TermJson.VariableSchema, isVariable, variableToJson, 'a variable'),\n  toCodecArbitrary: jsonLink(Generate.Variable, isVariable, variableToJson, 'a variable'),\n});\n\n/**\n * The type `VariableSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type VariableSchema = typeof VariableSchema.Type;\n\n/**\n * Schema of a triple term; its JSON codec is `TermJson.Triple`, and decoding rejects positions that don't fit RDF.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const TripleSchema: Schema.declare<Triple> = Schema.declare(isTriple, {\n  identifier: 'Triple',\n  toCodecJson: jsonLink(TermJson.TripleSchema, isTriple, tripleToJson, 'a well-formed triple term'),\n  toCodecArbitrary: jsonLink(Generate.Triple, isTriple, tripleToJson, 'a well-formed triple term'),\n});\n\n/**\n * The type `TripleSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type TripleSchema = typeof TripleSchema.Type;\n\n/**\n * Schema of a quad; its JSON codec is `TermJson.Quad`, with `graph` omitted for the default graph.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const QuadSchema: Schema.declare<Quad> = Schema.declare(isQuad, {\n  identifier: 'Quad',\n  toCodecJson: quadLink(TermJson.QuadSchema),\n  toCodecArbitrary: quadLink(Generate.Quad),\n});\n\n/**\n * The type `QuadSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type QuadSchema = typeof QuadSchema.Type;\n\n/**\n * Schema of any term; its JSON codec is `TermJson.Term`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const TermSchema: Schema.declare<Term> = Schema.declare(isTerm, {\n  identifier: 'Term',\n  toCodecJson: jsonLink(TermJson.TermSchema, isTerm, termToJson, 'a well-formed term'),\n  toCodecArbitrary: jsonLink(Generate.Term, isTerm, termToJson, 'a well-formed term'),\n});\n\n/**\n * The type `TermSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type TermSchema = typeof TermSchema.Type;\n\n/**\n * Schema of a ground term (no variables or default graph); its JSON codec is `TermJson.GroundTerm`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const GroundTermSchema: Schema.declare<GroundTerm> = Schema.declare(isGroundTerm, {\n  identifier: 'GroundTerm',\n  toCodecJson: jsonLink(\n    TermJson.GroundTermSchema,\n    isGroundTerm,\n    groundToJson,\n    'a well-formed ground term',\n  ),\n  toCodecArbitrary: jsonLink(\n    Generate.GroundTerm,\n    isGroundTerm,\n    groundToJson,\n    'a well-formed ground term',\n  ),\n});\n\n/**\n * The type `GroundTermSchema` decodes to.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type GroundTermSchema = typeof GroundTermSchema.Type;\n"],"mappings":"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"}

package/dist/Term.d.mts

@@ -0,0 +1,2 @@
+import { $ as isSubject, A as TypeId, B as fromJson, C as Resource, E as TermSchema, F as compare, G as isGround, H as isBlankNode, I as compareQuads, J as isLiteral, K as isGroundTerm, L as defaultGraph, M as VariableSchema, N as XSD_STRING, O as Triple, P as blankNode, Q as isResource, R as escapeIri, S as RDF_LANG_STRING, T as Term, U as isDefaultGraph, V as hasBlankNodes, W as isGraph, X as isObject, Y as isNamedNode, Z as isQuad, _ as Quad, a as Equivalence, at as mapTerms, b as QuadSchema, c as GroundTermSchema, ct as quadFromJson, d as NamedNode, dt as toQuad, et as isTerm, f as NamedNodeSchema, ft as triple, g as Predicate, h as PatternTerm, i as Direction, it as literal, j as Variable, k as TripleSchema, l as Literal, lt as quadToJson, m as Order, n as BlankNodeSchema, nt as isVariable, o as Graph, ot as namedNode, p as Object$1, pt as variable, q as isLanguageTagged, r as DefaultGraph, rt as isWellFormed, s as GroundTerm, st as quad, t as BlankNode, tt as isTriple, u as LiteralSchema, ut as toJson, v as QuadEquivalence, w as Subject, x as RDF_DIR_LANG_STRING, y as QuadOrder, z as escapeString } from "./Term-B_4ezyXq.mjs";
+export { BlankNode, BlankNodeSchema, DefaultGraph, Direction, Equivalence, Graph, GroundTerm, GroundTermSchema, Literal, LiteralSchema, NamedNode, NamedNodeSchema, Object$1 as Object, Order, PatternTerm, Predicate, Quad, QuadEquivalence, QuadOrder, QuadSchema, RDF_DIR_LANG_STRING, RDF_LANG_STRING, Resource, Subject, Term, TermSchema, Triple, TripleSchema, TypeId, Variable, VariableSchema, XSD_STRING, blankNode, compare, compareQuads, defaultGraph, escapeIri, escapeString, fromJson, hasBlankNodes, isBlankNode, isDefaultGraph, isGraph, isGround, isGroundTerm, isLanguageTagged, isLiteral, isNamedNode, isObject, isQuad, isResource, isSubject, isTerm, isTriple, isVariable, isWellFormed, literal, mapTerms, namedNode, quad, quadFromJson, quadToJson, toJson, toQuad, triple, variable };

package/dist/Term.mjs

@@ -0,0 +1 @@
+export { t as BlankNode, n as BlankNodeSchema, r as DefaultGraph, i as Equivalence, a as GroundTermSchema, o as Literal, s as LiteralSchema, c as NamedNode, l as NamedNodeSchema, u as Order, d as Quad, f as QuadEquivalence, p as QuadOrder, m as QuadSchema, h as RDF_DIR_LANG_STRING, g as RDF_LANG_STRING, _ as TermSchema, y as Triple, b as TripleSchema, x as TypeId, S as Variable, C as VariableSchema, w as XSD_STRING, T as blankNode, E as compare, D as compareQuads, O as defaultGraph, k as escapeIri, A as escapeString, j as fromJson, M as hasBlankNodes, N as isBlankNode, P as isDefaultGraph, F as isGraph, I as isGround, L as isGroundTerm, R as isLanguageTagged, z as isLiteral, B as isNamedNode, V as isObject, H as isQuad, U as isResource, W as isSubject, G as isTerm, K as isTriple, q as isVariable, J as isWellFormed, Y as literal, X as mapTerms, Z as namedNode, Q as quad, $ as quadFromJson, et as quadToJson, tt as toJson, nt as toQuad, rt as triple, it as variable } from "./Term-CFLG1qu4.mjs";

package/dist/TermCodec-CDZiEztW.mjs

@@ -0,0 +1,397 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, U as isResource, Y as literal$1, Z as namedNode$1, a as GroundTermSchema, l as NamedNodeSchema, s as LiteralSchema, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { S as toValue, _ as isValidLexical, c as dateTime$1, d as float$1, f as fromJs, g as isNumericDatatype, l as decimal$1, m as isIntegerDatatype, p as integer$1, r as boolean$1, u as double$1, x as toJs } from "./Xsd-Cdgx5zRB.mjs";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as BigDecimal from "effect/BigDecimal";
+import * as DateTime from "effect/DateTime";
+// src/TermCodec.ts
+/**
+* Effect `Schema`s that decode RDF terms to JavaScript values and encode them
+* back: typed access to the objects of a `Dataset`, SPARQL solutions, SHACL
+* or ShEx results and XMP properties.
+*
+* ```ts
+* const Person = Schema.Struct({
+*   name: TermCodec.string,
+*   age: Schema.optional(TermCodec.integer),
+*   homepage: Schema.optional(TermCodec.iri),
+* })
+* // QueryBuilder.decode(query, Person) : Stream<{ name: string; age?: number; … }>
+* ```
+*
+* Each schema's encoded side is a `Term.GroundTerm`, its decoded side a JS
+* value. Decoding fails (with a schema issue) when the term has the wrong
+* kind or datatype. Because `Term.GroundTermSchema` has a JSON codec,
+* `Schema.toCodecJson` of a struct of these codecs encodes to JSON terms.
+*
+* This module moved here from `@thomasfosterau/effect-rdf/sparql/TermSchema`,
+* which re-exports it.
+*
+* @since 0.1.0
+*/
+var TermCodec_exports = /* @__PURE__ */ __exportAll({
+	bigint: () => bigint,
+	boolean: () => boolean,
+	date: () => date,
+	dateTime: () => dateTime,
+	decimal: () => decimal,
+	double: () => double,
+	float: () => float,
+	integer: () => integer,
+	iri: () => iri,
+	langString: () => langString,
+	lexical: () => lexical,
+	literal: () => literal,
+	localized: () => localized,
+	make: () => make,
+	namedNode: () => namedNode,
+	number: () => number,
+	resource: () => resource,
+	string: () => string,
+	term: () => term,
+	typed: () => typed,
+	typedOneOf: () => typedOneOf,
+	value: () => value
+});
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/**
+* Builds a term codec from a (fallible) decoder and an encoder.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (target, options) => GroundTermSchema.pipe(Schema.decodeTo(target, SchemaTransformation.transformEffect({
+	decode: (term) => {
+		const value = options.decode(term);
+		return value === void 0 ? Effect.fail(new SchemaIssue.InvalidValue({ message: `Expected ${options.expected}, got ${term.toString()}` }, term)) : Effect.succeed(value);
+	},
+	encode: (value) => Effect.succeed(options.encode(value))
+})));
+const numericValue = (t) => {
+	if (!isLiteral(t) || !isNumericDatatype(t.datatype.value)) return Option.none();
+	if (!isValidLexical(t.datatype.value, t.value)) return Option.none();
+	const v = toValue(t);
+	return Match.value(v).pipe(Match.tag("Integer", (i) => Option.some(Number(i.value))), Match.tag("Decimal", (d) => Option.some(BigDecimal.toNumberUnsafe(d.value))), Match.tag("Float", "Double", (f) => Option.some(f.value)), Match.orElse(() => Option.none()));
+};
+/**
+* Any RDF term (identity).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const term = GroundTermSchema;
+/**
+* An IRI, decoded to a `NamedNode`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const namedNode = make(NamedNodeSchema, {
+	expected: "an IRI",
+	decode: (t) => isNamedNode(t) ? t : void 0,
+	encode: (n) => n
+});
+/**
+* An IRI, decoded to its string.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const iri = make(Schema.String, {
+	expected: "an IRI",
+	decode: (t) => isNamedNode(t) ? t.value : void 0,
+	encode: (s) => namedNode$1(s)
+});
+/**
+* A blank node or IRI (a resource), decoded to the term.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const resource = make(Schema.declare((u) => isResource(u)), {
+	expected: "an IRI or blank node",
+	decode: (t) => isResource(t) ? t : void 0,
+	encode: (r) => r
+});
+/**
+* Any literal, decoded to the `Literal` term.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const literal = make(LiteralSchema, {
+	expected: "a literal",
+	decode: (t) => isLiteral(t) ? t : void 0,
+	encode: (l) => l
+});
+/**
+* A string literal (simple, `xsd:string` or language-tagged), decoded to its
+* lexical form. Encodes to `xsd:string`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const string = make(Schema.String, {
+	expected: "a string literal",
+	decode: (t) => isLiteral(t) && (t.language !== "" || t.datatype.value === "http://www.w3.org/2001/XMLSchema#string") ? t.value : void 0,
+	encode: (s) => literal$1(s)
+});
+/**
+* The lexical form of any literal, or the string of an IRI.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const lexical = make(Schema.String, {
+	expected: "a literal or IRI",
+	decode: (t) => isLiteral(t) || isNamedNode(t) ? t.value : void 0,
+	encode: (s) => literal$1(s)
+});
+/**
+* A language-tagged string, decoded to `{ value, language, direction? }`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const langString = make(Schema.Struct({
+	value: Schema.String,
+	language: Schema.String,
+	direction: Schema.optional(Schema.Literals(["ltr", "rtl"]))
+}), {
+	expected: "a language-tagged string",
+	decode: (t) => isLiteral(t) && t.language !== "" ? t.direction !== void 0 ? {
+		value: t.value,
+		language: t.language,
+		direction: t.direction
+	} : {
+		value: t.value,
+		language: t.language
+	} : void 0,
+	encode: (v) => literal$1(v.value, {
+		language: v.language,
+		direction: v.direction
+	})
+});
+/**
+* Any numeric literal, decoded to a JS number. Encodes to `xsd:double`
+* (or `xsd:integer` for integral values).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const number = make(Schema.Number, {
+	expected: "a numeric literal",
+	decode: (t) => Option.getOrUndefined(numericValue(t)),
+	encode: (n) => Number.isInteger(n) ? integer$1(n) : double$1(n)
+});
+/**
+* An integer literal (`xsd:integer` and derived types), decoded to a JS
+* number.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const integer = make(Schema.Number, {
+	expected: "an integer literal",
+	decode: (t) => isLiteral(t) && isIntegerDatatype(t.datatype.value) ? Option.getOrUndefined(numericValue(t)) : void 0,
+	encode: (n) => integer$1(n)
+});
+/**
+* An integer literal decoded to a `bigint` (no precision loss).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const bigint = make(Schema.BigInt, {
+	expected: "an integer literal",
+	decode: (t) => isLiteral(t) && isIntegerDatatype(t.datatype.value) && isValidLexical(t.datatype.value, t.value) ? BigInt(t.value) : void 0,
+	encode: (n) => integer$1(n)
+});
+/**
+* A decimal (or integer) literal decoded to a `BigDecimal`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const decimal = make(Schema.declare((u) => BigDecimal.isBigDecimal(u)), {
+	expected: "a decimal literal",
+	decode: (t) => {
+		if (!isLiteral(t)) return void 0;
+		const v = toValue(t);
+		return Predicate.isTagged(v, "Decimal") ? v.value : Predicate.isTagged(v, "Integer") ? BigDecimal.fromBigInt(v.value) : void 0;
+	},
+	encode: (d) => decimal$1(d)
+});
+/**
+* An `xsd:boolean` literal.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const boolean = make(Schema.Boolean, {
+	expected: "a boolean literal",
+	decode: (t) => {
+		if (!isLiteral(t) || t.datatype.value !== `${XSD}boolean`) return void 0;
+		const v = toValue(t);
+		return Predicate.isTagged(v, "Boolean") ? v.value : void 0;
+	},
+	encode: (b) => boolean$1(b)
+});
+/**
+* An `xsd:dateTime` or `xsd:date` literal decoded to a `Date`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const date = make(Schema.Date, {
+	expected: "an xsd:dateTime or xsd:date literal",
+	decode: (t) => {
+		if (!isLiteral(t)) return void 0;
+		const v = toValue(t);
+		return Predicate.isTagged(v, "DateTime") && (v.kind === "dateTime" || v.kind === "date") ? Option.getOrUndefined(Option.map(DateTime.make(v.epochMillis), DateTime.toDateUtc)) : void 0;
+	},
+	encode: (d) => dateTime$1(d)
+});
+/**
+* A literal decoded to its natural JS value (see `Xsd.toJs`): strings,
+* numbers, bigints, booleans and dates.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const value = make(Schema.Union([
+	Schema.String,
+	Schema.Number,
+	Schema.BigInt,
+	Schema.Boolean,
+	Schema.Date
+]), {
+	expected: "a literal with a known datatype",
+	decode: (t) => {
+		if (!isLiteral(t)) return void 0;
+		return Option.getOrUndefined(toJs(t));
+	},
+	encode: (v) => fromJs(v)
+});
+/**
+* A literal with a specific datatype, decoded to its lexical form.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const typed = (datatype) => {
+	const datatypeIri = Predicate.isString(datatype) ? datatype : datatype.value;
+	return make(Schema.String, {
+		expected: `a literal of type <${datatypeIri}>`,
+		decode: (t) => isLiteral(t) && t.datatype.value === datatypeIri ? t.value : void 0,
+		encode: (s) => literal$1(s, namedNode$1(datatypeIri))
+	});
+};
+const literalOf = Match.type().pipe(Match.tag("Literal", (l) => Option.some(l)), Match.orElse(() => Option.none()));
+const withDatatype = (t, datatypes) => Option.filter(literalOf(t), (l) => datatypes.includes(l.datatype.value));
+/**
+* An `xsd:dateTime` or `xsd:dateTimeStamp` literal decoded to an Effect
+* `DateTime`: a `DateTime.Zoned` with a fixed offset when the lexical form
+* has a `±hh:mm` offset, otherwise (`Z`, or no timezone, read as UTC) a
+* `DateTime.Utc`. Encodes to `xsd:dateTime`, keeping a zoned value's offset.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const dateTime = make(Schema.Union([Schema.DateTimeUtc, Schema.DateTimeZoned]), {
+	expected: "an xsd:dateTime literal",
+	decode: (t) => Option.getOrUndefined(Option.flatMap(withDatatype(t, [`${XSD}dateTime`, `${XSD}dateTimeStamp`]), (l) => {
+		if (!isValidLexical(l.datatype.value, l.value)) return Option.none();
+		return Match.value(toValue(l)).pipe(Match.tag("DateTime", (v) => {
+			const utc = DateTime.make(v.epochMillis);
+			const offset = v.timezone;
+			return offset !== void 0 && /[+-]\d\d:\d\d$/.test(l.value) ? Option.flatMap(utc, (instant) => DateTime.makeZoned(instant, { timeZone: DateTime.zoneMakeOffset(offset * 6e4) })) : utc;
+		}), Match.orElse(() => Option.none()));
+	})),
+	encode: (d) => literal$1(DateTime.isZoned(d) ? DateTime.formatIsoOffset(d) : DateTime.formatIso(d), namedNode$1(`${XSD}dateTime`))
+});
+const floatingCodec = (local) => make(Schema.Number, {
+	expected: `an xsd:${local} literal`,
+	decode: (t) => Option.getOrUndefined(Option.flatMap(withDatatype(t, [`${XSD}${local}`]), (l) => isValidLexical(l.datatype.value, l.value) ? numericValue(l) : Option.none())),
+	encode: (n) => local === "double" ? double$1(n) : float$1(n)
+});
+/**
+* An `xsd:double` literal, decoded to a JS number and encoded back to
+* `xsd:double` (unlike `number`, which accepts any numeric datatype and
+* encodes integral values as `xsd:integer`).
+*
+* @since 0.1.0
+* @category schemas
+*/
+const double = floatingCodec("double");
+/**
+* An `xsd:float` literal, decoded to a JS number and encoded back to
+* `xsd:float`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const float = floatingCodec("float");
+/**
+* A string literal with an optional language tag and base direction: a
+* simple or `xsd:string` literal decodes to `{ value }`, a (directional)
+* language-tagged string to `{ value, language, direction? }`. Encodes back
+* to the same kind of literal.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const localized = make(Schema.Struct({
+	value: Schema.String,
+	language: Schema.optional(Schema.String),
+	direction: Schema.optional(Schema.Literals(["ltr", "rtl"]))
+}), {
+	expected: "a string or language-tagged string literal",
+	decode: (t) => Option.getOrUndefined(Option.flatMap(literalOf(t), (l) => {
+		if (l.language === "") return l.datatype.value === "http://www.w3.org/2001/XMLSchema#string" ? Option.some({ value: l.value }) : Option.none();
+		return Option.some(l.direction === void 0 ? {
+			value: l.value,
+			language: l.language
+		} : {
+			value: l.value,
+			language: l.language,
+			direction: l.direction
+		});
+	})),
+	encode: (v) => v.language === void 0 || v.language === "" ? literal$1(v.value) : literal$1(v.value, {
+		language: v.language,
+		direction: v.direction
+	})
+});
+/**
+* A literal whose datatype is any of `datatypes`, decoded to its lexical
+* form and datatype IRI (so encoding restores the same literal). Use it
+* where a property's range admits several datatypes, e.g. `xsd:date` or
+* `xsd:gYear`.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const typedOneOf = (datatypes) => {
+	const iris = datatypes.map((d) => Predicate.isString(d) ? d : d.value);
+	return make(Schema.Struct({
+		value: Schema.String,
+		datatype: Schema.Literals(iris)
+	}), {
+		expected: `a literal of type ${iris.map((dt) => `<${dt}>`).join(" or ")}`,
+		decode: (t) => Option.getOrUndefined(Option.map(withDatatype(t, iris), (l) => ({
+			value: l.value,
+			datatype: l.datatype.value
+		}))),
+		encode: (v) => literal$1(v.value, namedNode$1(v.datatype))
+	});
+};
+export { value as C, typedOneOf as S, number as _, dateTime as a, term as b, float as c, langString as d, lexical as f, namedNode as g, make as h, date as i, integer as l, localized as m, bigint as n, decimal as o, literal as p, boolean as r, double as s, TermCodec_exports as t, iri as u, resource as v, typed as x, string as y };
+
+//# sourceMappingURL=TermCodec-CDZiEztW.mjs.map

package/dist/TermCodec-CDZiEztW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TermCodec-CDZiEztW.mjs","names":["Term.isLiteral","Xsd.isNumericDatatype","Xsd.isValidLexical","Xsd.toValue","Term.GroundTermSchema","Term.NamedNodeSchema","Term.isNamedNode","Term.namedNode","Term.isResource","Term.LiteralSchema","Term.literal","Xsd.integer","Xsd.double","Xsd.isIntegerDatatype","Xsd.decimal","Xsd.boolean","Xsd.dateTime","Xsd.toJs","Xsd.fromJs","Xsd.float"],"sources":["../src/TermCodec.ts"],"sourcesContent":["/**\n * Effect `Schema`s that decode RDF terms to JavaScript values and encode them\n * back: typed access to the objects of a `Dataset`, SPARQL solutions, SHACL\n * or ShEx results and XMP properties.\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: TermCodec.string,\n *   age: Schema.optional(TermCodec.integer),\n *   homepage: Schema.optional(TermCodec.iri),\n * })\n * // QueryBuilder.decode(query, Person) : Stream<{ name: string; age?: number; … }>\n * ```\n *\n * Each schema's encoded side is a `Term.GroundTerm`, its decoded side a JS\n * value. Decoding fails (with a schema issue) when the term has the wrong\n * kind or datatype. Because `Term.GroundTermSchema` has a JSON codec,\n * `Schema.toCodecJson` of a struct of these codecs encodes to JSON terms.\n *\n * This module moved here from `@thomasfosterau/effect-rdf/sparql/TermSchema`,\n * which re-exports it.\n *\n * @since 0.1.0\n */\nimport * as BigDecimal from 'effect/BigDecimal';\nimport * as DateTime from 'effect/DateTime';\nimport * as Effect from 'effect/Effect';\nimport * as Match from 'effect/Match';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaIssue from 'effect/SchemaIssue';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as Term from './Term.ts';\nimport * as Xsd from './Xsd.ts';\nimport * as Predicate from 'effect/Predicate';\n\nconst XSD = 'http://www.w3.org/2001/XMLSchema#';\n\n/**\n * A schema decoding a term to a JS value of type `A`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type TermCodec<A> = Schema.Codec<A, Term.GroundTerm>;\n\n/**\n * Builds a term codec from a (fallible) decoder and an encoder.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <A>(\n  target: Schema.Codec<A>,\n  options: {\n    readonly expected: string;\n    readonly decode: (term: Term.GroundTerm) => A | undefined;\n    readonly encode: (value: A) => Term.GroundTerm;\n  },\n): TermCodec<A> =>\n  Term.GroundTermSchema.pipe(\n    Schema.decodeTo(\n      target,\n      SchemaTransformation.transformEffect({\n        decode: (term: Term.GroundTerm) => {\n          const value = options.decode(term);\n          return value === undefined\n            ? Effect.fail(\n                new SchemaIssue.InvalidValue(\n                  { message: `Expected ${options.expected}, got ${term.toString()}` },\n                  term,\n                ),\n              )\n            : Effect.succeed(value);\n        },\n        encode: (value: A) => Effect.succeed(options.encode(value)),\n      }),\n    ),\n  );\n\nconst numericValue = (t: Term.GroundTerm): Option.Option<number> => {\n  if (!Term.isLiteral(t) || !Xsd.isNumericDatatype(t.datatype.value)) return Option.none();\n  if (!Xsd.isValidLexical(t.datatype.value, t.value)) return Option.none();\n  const v = Xsd.toValue(t);\n  return Match.value(v).pipe(\n    Match.tag('Integer', (i) => Option.some(Number(i.value))),\n    Match.tag('Decimal', (d) => Option.some(BigDecimal.toNumberUnsafe(d.value))),\n    Match.tag('Float', 'Double', (f) => Option.some(f.value)),\n    Match.orElse(() => Option.none()),\n  );\n};\n\n/**\n * Any RDF term (identity).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const term: TermCodec<Term.GroundTerm> = Term.GroundTermSchema;\n\n/**\n * An IRI, decoded to a `NamedNode`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const namedNode: TermCodec<Term.NamedNode> = make(Term.NamedNodeSchema, {\n  expected: 'an IRI',\n  decode: (t) => (Term.isNamedNode(t) ? t : undefined),\n  encode: (n) => n,\n});\n\n/**\n * An IRI, decoded to its string.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const iri: TermCodec<string> = make(Schema.String, {\n  expected: 'an IRI',\n  decode: (t) => (Term.isNamedNode(t) ? t.value : undefined),\n  encode: (s) => Term.namedNode(s),\n});\n\n/**\n * A blank node or IRI (a resource), decoded to the term.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const resource: TermCodec<Term.Resource> = make(\n  Schema.declare((u): u is Term.Resource => Term.isResource(u)),\n  {\n    expected: 'an IRI or blank node',\n    decode: (t) => (Term.isResource(t) ? t : undefined),\n    encode: (r) => r,\n  },\n);\n\n/**\n * Any literal, decoded to the `Literal` term.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const literal: TermCodec<Term.Literal> = make(Term.LiteralSchema, {\n  expected: 'a literal',\n  decode: (t) => (Term.isLiteral(t) ? t : undefined),\n  encode: (l) => l,\n});\n\n/**\n * A string literal (simple, `xsd:string` or language-tagged), decoded to its\n * lexical form. Encodes to `xsd:string`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const string: TermCodec<string> = make(Schema.String, {\n  expected: 'a string literal',\n  decode: (t) =>\n    Term.isLiteral(t) && (t.language !== '' || t.datatype.value === Term.XSD_STRING)\n      ? t.value\n      : undefined,\n  encode: (s) => Term.literal(s),\n});\n\n/**\n * The lexical form of any literal, or the string of an IRI.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const lexical: TermCodec<string> = make(Schema.String, {\n  expected: 'a literal or IRI',\n  decode: (t) => (Term.isLiteral(t) || Term.isNamedNode(t) ? t.value : undefined),\n  encode: (s) => Term.literal(s),\n});\n\n/**\n * A language-tagged string, decoded to `{ value, language, direction? }`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const langString: TermCodec<{\n  readonly value: string;\n  readonly language: string;\n  readonly direction?: Term.Direction | undefined;\n}> = make(\n  Schema.Struct({\n    value: Schema.String,\n    language: Schema.String,\n    direction: Schema.optional(Schema.Literals(['ltr', 'rtl'])),\n  }),\n  {\n    expected: 'a language-tagged string',\n    decode: (t) =>\n      Term.isLiteral(t) && t.language !== ''\n        ? t.direction !== undefined\n          ? { value: t.value, language: t.language, direction: t.direction }\n          : { value: t.value, language: t.language }\n        : undefined,\n    encode: (v) => Term.literal(v.value, { language: v.language, direction: v.direction }),\n  },\n);\n\n/**\n * Any numeric literal, decoded to a JS number. Encodes to `xsd:double`\n * (or `xsd:integer` for integral values).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const number: TermCodec<number> = make(Schema.Number, {\n  expected: 'a numeric literal',\n  decode: (t) => Option.getOrUndefined(numericValue(t)),\n  encode: (n) => (Number.isInteger(n) ? Xsd.integer(n) : Xsd.double(n)),\n});\n\n/**\n * An integer literal (`xsd:integer` and derived types), decoded to a JS\n * number.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const integer: TermCodec<number> = make(Schema.Number, {\n  expected: 'an integer literal',\n  decode: (t) =>\n    Term.isLiteral(t) && Xsd.isIntegerDatatype(t.datatype.value)\n      ? Option.getOrUndefined(numericValue(t))\n      : undefined,\n  encode: (n) => Xsd.integer(n),\n});\n\n/**\n * An integer literal decoded to a `bigint` (no precision loss).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const bigint: TermCodec<bigint> = make(Schema.BigInt, {\n  expected: 'an integer literal',\n  decode: (t) =>\n    Term.isLiteral(t) &&\n    Xsd.isIntegerDatatype(t.datatype.value) &&\n    Xsd.isValidLexical(t.datatype.value, t.value)\n      ? BigInt(t.value)\n      : undefined,\n  encode: (n) => Xsd.integer(n),\n});\n\n/**\n * A decimal (or integer) literal decoded to a `BigDecimal`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const decimal: TermCodec<BigDecimal.BigDecimal> = make(\n  Schema.declare((u): u is BigDecimal.BigDecimal => BigDecimal.isBigDecimal(u)),\n  {\n    expected: 'a decimal literal',\n    decode: (t) => {\n      if (!Term.isLiteral(t)) return undefined;\n      const v = Xsd.toValue(t);\n      return Predicate.isTagged(v, 'Decimal')\n        ? v.value\n        : Predicate.isTagged(v, 'Integer')\n          ? BigDecimal.fromBigInt(v.value)\n          : undefined;\n    },\n    encode: (d) => Xsd.decimal(d),\n  },\n);\n\n/**\n * An `xsd:boolean` literal.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const boolean: TermCodec<boolean> = make(Schema.Boolean, {\n  expected: 'a boolean literal',\n  decode: (t) => {\n    if (!Term.isLiteral(t) || t.datatype.value !== `${XSD}boolean`) return undefined;\n    const v = Xsd.toValue(t);\n    return Predicate.isTagged(v, 'Boolean') ? v.value : undefined;\n  },\n  encode: (b) => Xsd.boolean(b),\n});\n\n/**\n * An `xsd:dateTime` or `xsd:date` literal decoded to a `Date`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const date: TermCodec<Date> = make(Schema.Date, {\n  expected: 'an xsd:dateTime or xsd:date literal',\n  decode: (t) => {\n    if (!Term.isLiteral(t)) return undefined;\n    const v = Xsd.toValue(t);\n    // An instant outside the range of `Date` does not decode.\n    return Predicate.isTagged(v, 'DateTime') && (v.kind === 'dateTime' || v.kind === 'date')\n      ? Option.getOrUndefined(Option.map(DateTime.make(v.epochMillis), DateTime.toDateUtc))\n      : undefined;\n  },\n  encode: (d) => Xsd.dateTime(d),\n});\n\n/**\n * A literal decoded to its natural JS value (see `Xsd.toJs`): strings,\n * numbers, bigints, booleans and dates.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const value: TermCodec<string | number | bigint | boolean | Date> = make(\n  Schema.Union([Schema.String, Schema.Number, Schema.BigInt, Schema.Boolean, Schema.Date]),\n  {\n    expected: 'a literal with a known datatype',\n    decode: (t) => {\n      if (!Term.isLiteral(t)) return undefined;\n      return Option.getOrUndefined(Xsd.toJs(t));\n    },\n    encode: (v) => Xsd.fromJs(v),\n  },\n);\n\n/**\n * A literal with a specific datatype, decoded to its lexical form.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const typed = (datatype: string | Term.NamedNode): TermCodec<string> => {\n  const datatypeIri = Predicate.isString(datatype) ? datatype : datatype.value;\n  return make(Schema.String, {\n    expected: `a literal of type <${datatypeIri}>`,\n    decode: (t) => (Term.isLiteral(t) && t.datatype.value === datatypeIri ? t.value : undefined),\n    encode: (s) => Term.literal(s, Term.namedNode(datatypeIri)),\n  });\n};\n\n// The literal a ground term is, if it is one. Built once: every new codec's decoder calls it.\nconst literalOf: (t: Term.GroundTerm) => Option.Option<Term.Literal> =\n  Match.type<Term.GroundTerm>().pipe(\n    Match.tag('Literal', (l) => Option.some(l)),\n    Match.orElse(() => Option.none()),\n  );\n\nconst withDatatype = (\n  t: Term.GroundTerm,\n  datatypes: ReadonlyArray<string>,\n): Option.Option<Term.Literal> =>\n  Option.filter(literalOf(t), (l) => datatypes.includes(l.datatype.value));\n\n/**\n * An `xsd:dateTime` or `xsd:dateTimeStamp` literal decoded to an Effect\n * `DateTime`: a `DateTime.Zoned` with a fixed offset when the lexical form\n * has a `±hh:mm` offset, otherwise (`Z`, or no timezone, read as UTC) a\n * `DateTime.Utc`. Encodes to `xsd:dateTime`, keeping a zoned value's offset.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const dateTime: TermCodec<DateTime.DateTime> = make(\n  Schema.Union([Schema.DateTimeUtc, Schema.DateTimeZoned]),\n  {\n    expected: 'an xsd:dateTime literal',\n    decode: (t) =>\n      Option.getOrUndefined(\n        Option.flatMap(withDatatype(t, [`${XSD}dateTime`, `${XSD}dateTimeStamp`]), (l) => {\n          if (!Xsd.isValidLexical(l.datatype.value, l.value)) return Option.none();\n          return Match.value(Xsd.toValue(l)).pipe(\n            Match.tag('DateTime', (v) => {\n              // An instant outside the range of `DateTime` does not decode.\n              const utc = DateTime.make(v.epochMillis);\n              const offset = v.timezone;\n              return offset !== undefined && /[+-]\\d\\d:\\d\\d$/.test(l.value)\n                ? Option.flatMap(utc, (instant) =>\n                    DateTime.makeZoned(instant, {\n                      timeZone: DateTime.zoneMakeOffset(offset * 60_000),\n                    }),\n                  )\n                : utc;\n            }),\n            Match.orElse(() => Option.none()),\n          );\n        }),\n      ),\n    encode: (d) =>\n      Term.literal(\n        DateTime.isZoned(d) ? DateTime.formatIsoOffset(d) : DateTime.formatIso(d),\n        Term.namedNode(`${XSD}dateTime`),\n      ),\n  },\n);\n\nconst floatingCodec = (local: 'double' | 'float') =>\n  make(Schema.Number, {\n    expected: `an xsd:${local} literal`,\n    decode: (t) =>\n      Option.getOrUndefined(\n        Option.flatMap(withDatatype(t, [`${XSD}${local}`]), (l) =>\n          Xsd.isValidLexical(l.datatype.value, l.value) ? numericValue(l) : Option.none(),\n        ),\n      ),\n    encode: (n) => (local === 'double' ? Xsd.double(n) : Xsd.float(n)),\n  });\n\n/**\n * An `xsd:double` literal, decoded to a JS number and encoded back to\n * `xsd:double` (unlike `number`, which accepts any numeric datatype and\n * encodes integral values as `xsd:integer`).\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const double: TermCodec<number> = floatingCodec('double');\n\n/**\n * An `xsd:float` literal, decoded to a JS number and encoded back to\n * `xsd:float`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const float: TermCodec<number> = floatingCodec('float');\n\n/**\n * The value `localized` decodes to: a string with an optional language tag\n * and base direction.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LocalizedString {\n  readonly value: string;\n  readonly language?: string | undefined;\n  readonly direction?: Term.Direction | undefined;\n}\n\n/**\n * A string literal with an optional language tag and base direction: a\n * simple or `xsd:string` literal decodes to `{ value }`, a (directional)\n * language-tagged string to `{ value, language, direction? }`. Encodes back\n * to the same kind of literal.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const localized: TermCodec<LocalizedString> = make<LocalizedString>(\n  Schema.Struct({\n    value: Schema.String,\n    language: Schema.optional(Schema.String),\n    direction: Schema.optional(Schema.Literals(['ltr', 'rtl'])),\n  }),\n  {\n    expected: 'a string or language-tagged string literal',\n    decode: (t) =>\n      Option.getOrUndefined(\n        Option.flatMap(literalOf(t), (l) => {\n          if (l.language === '') {\n            return l.datatype.value === Term.XSD_STRING\n              ? Option.some({ value: l.value })\n              : Option.none();\n          }\n          return Option.some(\n            l.direction === undefined\n              ? { value: l.value, language: l.language }\n              : { value: l.value, language: l.language, direction: l.direction },\n          );\n        }),\n      ),\n    encode: (v) =>\n      v.language === undefined || v.language === ''\n        ? Term.literal(v.value)\n        : Term.literal(v.value, { language: v.language, direction: v.direction }),\n  },\n);\n\n/**\n * A literal whose datatype is any of `datatypes`, decoded to its lexical\n * form and datatype IRI (so encoding restores the same literal). Use it\n * where a property's range admits several datatypes, e.g. `xsd:date` or\n * `xsd:gYear`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const typedOneOf = (\n  datatypes: ReadonlyArray<string | Term.NamedNode>,\n): TermCodec<{ readonly value: string; readonly datatype: string }> => {\n  const iris = datatypes.map((d) => (Predicate.isString(d) ? d : d.value));\n  return make(Schema.Struct({ value: Schema.String, datatype: Schema.Literals(iris) }), {\n    expected: `a literal of type ${iris.map((dt) => `<${dt}>`).join(' or ')}`,\n    decode: (t) =>\n      Option.getOrUndefined(\n        Option.map(withDatatype(t, iris), (l) => ({ value: l.value, datatype: l.datatype.value })),\n      ),\n    encode: (v) => Term.literal(v.value, Term.namedNode(v.datatype)),\n  });\n};\n"],"mappings":"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"}