@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Evaluator-DOY2-guC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Evaluator-DOY2-guC.mjs","names":["Vocabulary","Vocab","Term.isResource","Sparql.SparqlEvaluationError","Term.literal","Dataset.objectsOf","Term.isNamedNode","Message.localName","Term.isLiteral","Bindings.fromEntries","Path.predicate","Term.namedNode","Term.Quad","Term.defaultGraph","Store.makeMemory","Dataset.fromIterable","Engine.make","compile","Path.toSparql","Query.compile","Term.isBlankNode","Sparql.SparqlConstraintEvaluator"],"sources":["../src/sparql/shacl/Evaluator.ts"],"sourcesContent":["/**\n * The SHACL-SPARQL evaluator: an implementation of the\n * `Sparql.SparqlConstraintEvaluator` service of `@thomasfosterau/effect-rdf/shacl`\n * on the `@thomasfosterau/effect-rdf/sparql` engine. With it in the context,\n * `Validator.validate` supports\n *\n * - SPARQL-based constraints (`sh:sparql`, §5),\n * - SPARQL-based constraint components with `SELECT` validators\n *   (`sh:nodeValidator`, `sh:propertyValidator`) and `ASK` validators\n *   (`sh:validator`), with mandatory and optional parameters (§6),\n * - SPARQL-based targets (`sh:SPARQLTarget`) and target types\n *   (`sh:SPARQLTargetType`) of SHACL Advanced Features,\n *\n * with the pre-bound variables `$this`, `$value`, `$currentShape`,\n * `$shapesGraph` and the parameters, `$PATH` substitution, prefix\n * declarations (`sh:prefixes` / `sh:declare`) and the `?path`, `?value`,\n * `?message` and `?failure` result variables.\n *\n * ```ts\n * import { Effect } from \"effect\"\n * import { Validator } from \"@thomasfosterau/effect-rdf/shacl\"\n * import { Evaluator } from \"@thomasfosterau/effect-rdf/sparql/shacl\"\n *\n * const report = Validator.validate(dataGraph, shapesGraph).pipe(\n *   Effect.provide(Evaluator.layer()),\n * )\n * ```\n *\n * The data graph is queried as the default graph; the shapes graph is\n * available as the named graph `$shapesGraph` (`GRAPH $shapesGraph { … }`).\n *\n * @since 0.1.0\n */\nimport { Dataset, Term, Vocab } from '../../index.ts';\nimport { Message, Path, Shapes, Sparql, Vocabulary } from '../../shacl/index.ts';\nimport { type Ast, Bindings, Engine, Store } from '../index.ts';\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport { pipe } from 'effect/Function';\nimport * as HashSet from 'effect/HashSet';\nimport * as Layer from 'effect/Layer';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Result from 'effect/Result';\nimport * as Stream from 'effect/Stream';\nimport * as Query from './Query.ts';\n\nconst { sh } = Vocabulary;\nconst { rdf, xsd } = Vocab;\n\n/**\n * Evaluator configuration.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface EvaluatorOptions {\n  /**\n   * The IRI under which the shapes graph is visible as a named graph\n   * (`$shapesGraph`). Defaults to `urn:x-shacl:shapesGraph`.\n   */\n  readonly shapesGraphIri?: string | undefined;\n  /** Options of the SPARQL engine (e.g. extension `functions`). */\n  readonly engine?: Omit<Engine.EngineOptions, 'unionDefaultGraph'> | undefined;\n}\n\n/**\n * The default IRI of the shapes graph as seen from SPARQL queries.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const defaultShapesGraphIri = 'urn:x-shacl:shapesGraph';\n\n/** The variables pre-bound for every constraint query. */\nconst constraintVariables = ['this', 'shapesGraph', 'currentShape'] as const;\n/** Parameter names that would clash with SHACL-SPARQL variables. */\nconst reservedNames = HashSet.make('this', 'shapesGraph', 'currentShape', 'path', 'PATH', 'value');\nconst varName = /^[\\p{L}\\p{N}_][\\p{L}\\p{N}_\\p{M}]*$/u;\n\ntype Node = Term.NamedNode | Term.BlankNode;\ntype Solution = ReadonlyMap<string, Term.GroundTerm>;\n\nconst isNode: (t: Term.Term) => t is Node = Term.isResource;\n\nconst evaluationError = (message: string, cause?: unknown) =>\n  new Sparql.SparqlEvaluationError(cause === undefined ? { message } : { message, cause });\n\nconst TRUE = Term.literal('true', xsd.boolean).key;\n\ninterface Parameter {\n  readonly path: Term.NamedNode;\n  readonly name: string;\n  readonly optional: boolean;\n}\n\n/** Reads one `sh:parameter` declaration, given the parameters read before it. */\nconst readParameter = (\n  shapes: Dataset.Dataset,\n  declaration: Node,\n  parameter: Term.GroundTerm,\n  out: ReadonlyArray<Parameter>,\n): Result.Result<ReadonlyArray<Parameter>, Sparql.SparqlEvaluationError> => {\n  const paths = isNode(parameter) ? Dataset.objectsOf(shapes, parameter, sh.path) : [];\n  const path =\n    paths.length === 1 ? Option.filter(Arr.head(paths), Term.isNamedNode) : Option.none();\n  if (Option.isNone(path)) {\n    return Result.fail(\n      evaluationError(`parameter ${parameter.key} of ${declaration.key} needs one IRI sh:path`),\n    );\n  }\n  const name = Message.localName(path.value);\n  if (!varName.test(name) || HashSet.has(reservedNames, name)) {\n    return Result.fail(\n      evaluationError(\n        `parameter ${path.value.key} of ${declaration.key} has invalid name \"${name}\"`,\n      ),\n    );\n  }\n  if (out.some((p) => p.name === name)) {\n    return Result.fail(\n      evaluationError(`${declaration.key} declares two parameters named \"${name}\"`),\n    );\n  }\n  const optional = isNode(parameter)\n    ? Dataset.objectsOf(shapes, parameter, sh.optional).some((o) => o.key === TRUE)\n    : false;\n  return Result.succeed(Arr.append(out, { path: path.value, name, optional }));\n};\n\nconst noParameters: Result.Result<\n  ReadonlyArray<Parameter>,\n  Sparql.SparqlEvaluationError\n> = Result.succeed([]);\n\n/** The declared parameters of a constraint component or target type, with their names. */\nconst parametersOf = (\n  shapes: Dataset.Dataset,\n  declaration: Node,\n): Effect.Effect<ReadonlyArray<Parameter>, Sparql.SparqlEvaluationError> =>\n  Effect.suspend(() =>\n    Effect.fromResult(\n      Arr.reduce(\n        Dataset.objectsOf(shapes, declaration, sh.parameter),\n        noParameters,\n        (acc, parameter) =>\n          Result.flatMap(acc, (out) => readParameter(shapes, declaration, parameter, out)),\n      ),\n    ),\n  );\n\nconst literals = (shapes: Dataset.Dataset, node: Node, p: Term.NamedNode) =>\n  Dataset.objectsOf(shapes, node, p).filter(Term.isLiteral);\n\ntype Bound = Iterable<readonly [string, Term.GroundTerm]>;\n\nconst prebinding = (record: Bound) => ({\n  bindings: Bindings.fromEntries(record),\n});\n\n/** Maps a solution to a violation (§5.3.2 \"Mapping of Solution Bindings to Result Properties\"). */\nconst toViolation = (\n  solution: Solution,\n  shape: Shapes.Shape,\n  messages: ReadonlyArray<Term.Literal>,\n  parameters: ReadonlyArray<readonly [string, Term.GroundTerm]>,\n): Effect.Effect<Sparql.Violation, Sparql.SparqlEvaluationError> => {\n  const failure = solution.get('failure');\n  if (failure !== undefined && failure.key === TRUE) {\n    return Effect.fail(\n      evaluationError(`a SPARQL constraint of ${shape.id.key} reported a failure`),\n    );\n  }\n  const path = solution.get('path');\n  const value = solution.get('value');\n  const message = solution.get('message');\n  // Solution bindings take precedence over parameter values of the same name.\n  const bindings = Bindings.fromEntries([...parameters, ...solution]).map;\n  return Effect.succeed({\n    focusNode: solution.get('this'),\n    path: Term.isNamedNode(path) ? Path.predicate(path) : undefined,\n    value: value ?? (Predicate.isTagged(shape, 'NodeShape') ? solution.get('this') : undefined),\n    messages: Term.isLiteral(message) ? [message] : messages,\n    bindings,\n  });\n};\n\ninterface ValidatorQuery {\n  readonly node: Node;\n  readonly form: 'select' | 'ask';\n}\n\n/** Selects the validator of a constraint component for a shape (§6.2.3). */\nconst validatorOf = (\n  shapes: Dataset.Dataset,\n  component: Node,\n  shape: Shapes.Shape,\n): Option.Option<ValidatorQuery> => {\n  const withQuery = (p: Term.NamedNode, query: Term.NamedNode, form: ValidatorQuery['form']) =>\n    Option.map(\n      Arr.findFirst(Dataset.objectsOf(shapes, component, p).filter(isNode), (v) =>\n        Arr.isReadonlyArrayNonEmpty(Dataset.objectsOf(shapes, v, query)),\n      ),\n      (node): ValidatorQuery => ({ node, form }),\n    );\n  return pipe(\n    Predicate.isTagged(shape, 'NodeShape')\n      ? withQuery(sh.nodeValidator, sh.select, 'select')\n      : withQuery(sh.propertyValidator, sh.select, 'select'),\n    Option.orElse(() => withQuery(sh.validator, sh.ask, 'ask')),\n  );\n};\n\nconst focusNodes = (solutions: ReadonlyArray<Solution>) =>\n  solutions.flatMap((s) => {\n    const t = s.get('this');\n    return t === undefined ? [] : [t];\n  });\n\n/**\n * Creates the evaluator service.\n *\n * Per data graph (and shapes graph) the evaluator builds an in-memory\n * SPARQL store once and caches compiled queries, so validating many focus\n * nodes does not re-parse queries.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (\n  options: EvaluatorOptions = {},\n): Sparql.SparqlConstraintEvaluator['Service'] => {\n  const shapesGraphNode = Term.namedNode(options.shapesGraphIri ?? defaultShapesGraphIri);\n\n  interface Context {\n    readonly engine: Engine.SparqlEngineShape;\n    readonly queries: MutableHashMap.MutableHashMap<string, Ast.Query>;\n  }\n  const contexts = new WeakMap<Dataset.Dataset, WeakMap<Dataset.Dataset, Context>>();\n\n  const contextFor = (data: Dataset.Dataset, shapes: Dataset.Dataset): Effect.Effect<Context> =>\n    Effect.suspend(() => {\n      let byShapes = contexts.get(data);\n      if (byShapes === undefined) contexts.set(data, (byShapes = new WeakMap()));\n      const cached = byShapes.get(shapes);\n      if (cached !== undefined) return Effect.succeed(cached);\n      const quads = [\n        ...Arr.map(\n          Arr.fromIterable(data),\n          (q) => new Term.Quad(q.subject, q.predicate, q.object, Term.defaultGraph),\n        ),\n        ...Arr.map(\n          Arr.fromIterable(shapes),\n          (q) => new Term.Quad(q.subject, q.predicate, q.object, shapesGraphNode),\n        ),\n      ];\n      return Effect.map(Store.makeMemory(Dataset.fromIterable(quads)), (store) => {\n        const context: Context = {\n          engine: Engine.make(store, { ...options.engine, unionDefaultGraph: false }),\n          queries: MutableHashMap.empty(),\n        };\n        byShapes.set(shapes, context);\n        return context;\n      });\n    });\n\n  const compile = (\n    context: Context,\n    shapes: Dataset.Dataset,\n    node: Node,\n    compileOptions: Query.CompileOptions,\n  ): Effect.Effect<Ast.Query, Sparql.SparqlEvaluationError> => {\n    const key = [\n      compileOptions.form,\n      node.key,\n      compileOptions.path === undefined ? '' : Path.toSparql(compileOptions.path),\n      ...compileOptions.prebound,\n    ].join(' ');\n    return Option.match(MutableHashMap.get(context.queries, key), {\n      onSome: Effect.succeed,\n      onNone: () =>\n        Effect.tap(Query.compile(shapes, node, compileOptions), (q) =>\n          Effect.sync(() => MutableHashMap.set(context.queries, key, q)),\n        ),\n    });\n  };\n\n  const select = (\n    context: Context,\n    query: Ast.Query,\n    bound: Bound,\n  ): Effect.Effect<ReadonlyArray<Solution>, Sparql.SparqlEvaluationError> =>\n    context.engine.select(query, prebinding(bound)).pipe(\n      Effect.flatMap((result) => Stream.runCollect(result.bindings)),\n      Effect.map((solutions) => solutions.map((s) => s.map)),\n      Effect.mapError((e) => evaluationError(`SPARQL evaluation failed: ${e.message}`, e)),\n    );\n\n  const ask = (\n    context: Context,\n    query: Ast.Query,\n    bound: Bound,\n  ): Effect.Effect<boolean, Sparql.SparqlEvaluationError> =>\n    context.engine\n      .ask(query, prebinding(bound))\n      .pipe(Effect.mapError((e) => evaluationError(`SPARQL evaluation failed: ${e.message}`, e)));\n\n  const evaluateSparqlConstraint = Effect.fnUntraced(function* (\n    input: Sparql.ConstraintInput,\n    constraint: Shapes.SparqlConstraint,\n  ) {\n    const shapes = input.shapesGraph.dataset;\n    const context = yield* contextFor(input.dataGraph, shapes);\n    const query = yield* compile(context, shapes, constraint.node, {\n      form: 'select',\n      prebound: constraintVariables,\n      project: ['this'],\n      path: Predicate.isTagged(input.shape, 'PropertyShape') ? input.shape.path : undefined,\n    });\n    const solutions = yield* select(context, query, [\n      ['this', input.focusNode],\n      ['shapesGraph', shapesGraphNode],\n      ['currentShape', input.shape.id],\n    ]);\n    const messages = literals(shapes, constraint.node, sh.message);\n    return yield* Effect.forEach(solutions, (s) => toViolation(s, input.shape, messages, []), {\n      concurrency: 1,\n    });\n  });\n\n  const evaluateComponent = Effect.fnUntraced(function* (\n    input: Sparql.ConstraintInput,\n    constraint: Shapes.ComponentConstraint,\n  ) {\n    const shapes = input.shapesGraph.dataset;\n    const found = validatorOf(shapes, constraint.component, input.shape);\n    if (Option.isNone(found)) return [];\n    const validator = found.value;\n    const declared = yield* parametersOf(shapes, constraint.component);\n    const parameters = constraint.parameters.map((p) => {\n      const name =\n        declared.find((d) => d.path.key === p.path.key)?.name ?? Message.localName(p.path);\n      return [name, p.value] as const;\n    });\n    const context = yield* contextFor(input.dataGraph, shapes);\n    const potentiallyBound = [\n      ...constraintVariables,\n      ...declared.map((d) => d.name),\n      ...(validator.form === 'ask' ? ['value'] : []),\n    ];\n    const query = yield* compile(context, shapes, validator.node, {\n      form: validator.form,\n      prebound: potentiallyBound,\n      project: validator.form === 'select' ? ['this'] : [],\n      path:\n        validator.form === 'select' && Predicate.isTagged(input.shape, 'PropertyShape')\n          ? input.shape.path\n          : undefined,\n    });\n    const validatorMessages = literals(shapes, validator.node, sh.message);\n    const messages = Arr.isReadonlyArrayNonEmpty(validatorMessages)\n      ? validatorMessages\n      : literals(shapes, constraint.component, sh.message);\n    const bound: Array<readonly [string, Term.GroundTerm]> = [\n      ['this', input.focusNode],\n      ['shapesGraph', shapesGraphNode],\n      ['currentShape', input.shape.id],\n      ...parameters,\n    ];\n    if (validator.form === 'select') {\n      const solutions = yield* select(context, query, bound);\n      return yield* Effect.forEach(\n        solutions,\n        (s) => toViolation(s, input.shape, messages, parameters),\n        { concurrency: 1 },\n      );\n    }\n    const failing = yield* Effect.filter(input.valueNodes, (value) =>\n      Effect.map(ask(context, query, [...bound, ['value', value]]), (ok) => !ok),\n    );\n    return yield* Effect.forEach(\n      failing,\n      (value) =>\n        toViolation(\n          Bindings.fromEntries([\n            ['this', input.focusNode],\n            ['value', value],\n          ]).map,\n          input.shape,\n          messages,\n          parameters,\n        ),\n      { concurrency: 1 },\n    );\n  });\n\n  const evaluateConstraint: Sparql.SparqlConstraintEvaluator['Service']['evaluateConstraint'] = (\n    input,\n  ) =>\n    Predicate.isTagged(input.constraint, 'Sparql')\n      ? evaluateSparqlConstraint(input, input.constraint)\n      : evaluateComponent(input, input.constraint);\n\n  const selectTargets: Sparql.SparqlConstraintEvaluator['Service']['selectTargets'] =\n    Effect.fnUntraced(function* (input) {\n      const shapes = input.shapesGraph.dataset;\n      const target = input.target;\n      if (!isNode(target)) {\n        return yield* Effect.fail(\n          evaluationError(`sh:target of ${input.shape.id.key} must be an IRI or blank node`),\n        );\n      }\n      const context = yield* contextFor(input.dataGraph, shapes);\n\n      // SPARQL-based target: the target node carries the query.\n      if (Arr.isReadonlyArrayNonEmpty(Dataset.objectsOf(shapes, target, sh.select))) {\n        const query = yield* compile(context, shapes, target, {\n          form: 'select',\n          prebound: [],\n          project: ['this'],\n        });\n        return focusNodes(yield* select(context, query, []));\n      }\n\n      // SPARQL-based target type: a type of the target node carries the query.\n      const type = Dataset.objectsOf(shapes, target, rdf.type)\n        .filter(isNode)\n        .find((t) => Arr.isReadonlyArrayNonEmpty(Dataset.objectsOf(shapes, t, sh.select)));\n      if (type === undefined) {\n        return yield* Effect.fail(\n          evaluationError(\n            `unsupported custom target ${target.key} of ${input.shape.id.key} (neither a sh:SPARQLTarget nor an instance of a sh:SPARQLTargetType)`,\n          ),\n        );\n      }\n      const declared = yield* parametersOf(shapes, type);\n      const supplied = declared.map((parameter) => ({\n        parameter,\n        values: Dataset.objectsOf(shapes, target, parameter.path),\n      }));\n      const invalid = ({ values }: (typeof supplied)[number]) =>\n        values.length > 1 || values.some(Term.isBlankNode);\n      // The first parameter that is ill-valued or required but missing decides,\n      // in declaration order.\n      const problem = supplied.find(\n        (s) => invalid(s) || (Arr.isReadonlyArrayEmpty(s.values) && !s.parameter.optional),\n      );\n      if (problem !== undefined) {\n        if (!invalid(problem)) return [];\n        return yield* Effect.fail(\n          evaluationError(\n            `target ${target.key} needs at most one non-blank value for ${problem.parameter.path.key}`,\n          ),\n        );\n      }\n      const bound = supplied.flatMap(({ parameter, values }) =>\n        values.slice(0, 1).map((value) => [parameter.name, value] as const),\n      );\n      const query = yield* compile(context, shapes, type, {\n        form: 'select',\n        prebound: declared.map((d) => d.name),\n        project: ['this'],\n      });\n      return focusNodes(yield* select(context, query, bound));\n    });\n\n  return Sparql.SparqlConstraintEvaluator.of({ evaluateConstraint, selectTargets });\n};\n\n/**\n * A layer providing the SHACL-SPARQL evaluator.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = (options?: EvaluatorOptions): Layer.Layer<Sparql.SparqlConstraintEvaluator> =>\n  Layer.sync(Sparql.SparqlConstraintEvaluator, () => make(options));\n"],"mappings":"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"}

package/dist/Exif-CpqniYQd.d.mts

@@ -0,0 +1,78 @@
+import { a as LocalizedSetter, c as Setter, o as Metadata } from "./Metadata-nzS7QKRj.mjs";
+import * as Option from "effect/Option";
+import * as DateTime from "effect/DateTime";
+declare namespace Exif_d_exports {
+  export { dateTimeDigitized, dateTimeOriginal, pixelXDimension, pixelYDimension, setDateTimeDigitized, setDateTimeOriginal, setPixelXDimension, setPixelYDimension, setUserComment, userComment };
+}
+/**
+ * When the original image was taken (`exif:DateTimeOriginal`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const dateTimeOriginal: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets when the original image was taken (`exif:DateTimeOriginal`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setDateTimeOriginal: Setter<DateTime.DateTime | string>;
+/**
+ * When the image was stored as digital data (`exif:DateTimeDigitized`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const dateTimeDigitized: (self: Metadata) => Option.Option<string>;
+/**
+ * Sets when the image was stored as digital data (`exif:DateTimeDigitized`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setDateTimeDigitized: Setter<DateTime.DateTime | string>;
+/**
+ * A user comment (`exif:UserComment`). A language alternative; reads the item in `language` (default `x-default`).
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const userComment: (self: Metadata, language?: string) => Option.Option<string>;
+/**
+ * Sets a user comment (`exif:UserComment`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setUserComment: LocalizedSetter;
+/**
+ * The valid image width, in pixels (`exif:PixelXDimension`). An integer.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const pixelXDimension: (self: Metadata) => Option.Option<number>;
+/**
+ * Sets the valid image width, in pixels (`exif:PixelXDimension`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setPixelXDimension: Setter<number>;
+/**
+ * The valid image height, in pixels (`exif:PixelYDimension`). An integer.
+ *
+ * @since 0.1.0
+ * @category getters
+ */
+declare const pixelYDimension: (self: Metadata) => Option.Option<number>;
+/**
+ * Sets the valid image height, in pixels (`exif:PixelYDimension`).
+ *
+ * @since 0.1.0
+ * @category setters
+ */
+declare const setPixelYDimension: Setter<number>;
+export { pixelYDimension as a, setPixelXDimension as c, userComment as d, pixelXDimension as i, setPixelYDimension as l, dateTimeDigitized as n, setDateTimeDigitized as o, dateTimeOriginal as r, setDateTimeOriginal as s, Exif_d_exports as t, setUserComment as u };
+//# sourceMappingURL=Exif-CpqniYQd.d.mts.map

package/dist/Exif-DjkCfEB-.mjs

@@ -0,0 +1,89 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { n as EXIF } from "./Namespaces-Bz85vpjW.mjs";
+import { a as localized, c as setDate, l as setInteger, p as text, r as integer, u as setLocalized } from "./accessors-CEjaojuQ.mjs";
+// src/xmp/Exif.ts
+var Exif_exports = /* @__PURE__ */ __exportAll({
+	dateTimeDigitized: () => dateTimeDigitized,
+	dateTimeOriginal: () => dateTimeOriginal,
+	pixelXDimension: () => pixelXDimension,
+	pixelYDimension: () => pixelYDimension,
+	setDateTimeDigitized: () => setDateTimeDigitized,
+	setDateTimeOriginal: () => setDateTimeOriginal,
+	setPixelXDimension: () => setPixelXDimension,
+	setPixelYDimension: () => setPixelYDimension,
+	setUserComment: () => setUserComment,
+	userComment: () => userComment
+});
+/**
+* When the original image was taken (`exif:DateTimeOriginal`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.
+*
+* @since 0.1.0
+* @category getters
+*/
+const dateTimeOriginal = text(`${EXIF}DateTimeOriginal`);
+/**
+* Sets when the original image was taken (`exif:DateTimeOriginal`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setDateTimeOriginal = setDate(`${EXIF}DateTimeOriginal`);
+/**
+* When the image was stored as digital data (`exif:DateTimeDigitized`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.
+*
+* @since 0.1.0
+* @category getters
+*/
+const dateTimeDigitized = text(`${EXIF}DateTimeDigitized`);
+/**
+* Sets when the image was stored as digital data (`exif:DateTimeDigitized`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setDateTimeDigitized = setDate(`${EXIF}DateTimeDigitized`);
+/**
+* A user comment (`exif:UserComment`). A language alternative; reads the item in `language` (default `x-default`).
+*
+* @since 0.1.0
+* @category getters
+*/
+const userComment = localized(`${EXIF}UserComment`);
+/**
+* Sets a user comment (`exif:UserComment`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setUserComment = setLocalized(`${EXIF}UserComment`);
+/**
+* The valid image width, in pixels (`exif:PixelXDimension`). An integer.
+*
+* @since 0.1.0
+* @category getters
+*/
+const pixelXDimension = integer(`${EXIF}PixelXDimension`);
+/**
+* Sets the valid image width, in pixels (`exif:PixelXDimension`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setPixelXDimension = setInteger(`${EXIF}PixelXDimension`);
+/**
+* The valid image height, in pixels (`exif:PixelYDimension`). An integer.
+*
+* @since 0.1.0
+* @category getters
+*/
+const pixelYDimension = integer(`${EXIF}PixelYDimension`);
+/**
+* Sets the valid image height, in pixels (`exif:PixelYDimension`).
+*
+* @since 0.1.0
+* @category setters
+*/
+const setPixelYDimension = setInteger(`${EXIF}PixelYDimension`);
+export { pixelYDimension as a, setPixelXDimension as c, userComment as d, pixelXDimension as i, setPixelYDimension as l, dateTimeDigitized as n, setDateTimeDigitized as o, dateTimeOriginal as r, setDateTimeOriginal as s, Exif_exports as t, setUserComment as u };
+
+//# sourceMappingURL=Exif-DjkCfEB-.mjs.map

package/dist/Exif-DjkCfEB-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Exif-DjkCfEB-.mjs","names":["Accessors.text","Accessors.setDate","Accessors.localized","Accessors.setLocalized","Accessors.integer","Accessors.setInteger"],"sources":["../src/xmp/Exif.ts"],"sourcesContent":["/**\n * Typed accessors for the most used properties of the EXIF schema (`exif:`,\n * XMP Specification Part 2 §3.3.6). Any other EXIF property is read with\n * `Metadata.get`.\n *\n * @since 0.1.0\n */\nimport type * as DateTime from 'effect/DateTime';\nimport type * as Option from 'effect/Option';\nimport * as Accessors from './internal/accessors.ts';\nimport type * as Metadata from './Metadata.ts';\nimport { EXIF } from './Namespaces.ts';\n\n/**\n * When the original image was taken (`exif:DateTimeOriginal`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const dateTimeOriginal: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(\n  `${EXIF}DateTimeOriginal`,\n);\n\n/**\n * Sets when the original image was taken (`exif:DateTimeOriginal`).\n *\n * @since 0.1.0\n * @category setters\n */\nexport const setDateTimeOriginal: Metadata.Setter<DateTime.DateTime | string> = Accessors.setDate(\n  `${EXIF}DateTimeOriginal`,\n);\n\n/**\n * When the image was stored as digital data (`exif:DateTimeDigitized`). An ISO 8601 date, as XMP stores it; the setter takes a `DateTime` or a string.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const dateTimeDigitized: (self: Metadata.Metadata) => Option.Option<string> = Accessors.text(\n  `${EXIF}DateTimeDigitized`,\n);\n\n/**\n * Sets when the image was stored as digital data (`exif:DateTimeDigitized`).\n *\n * @since 0.1.0\n * @category setters\n */\nexport const setDateTimeDigitized: Metadata.Setter<DateTime.DateTime | string> = Accessors.setDate(\n  `${EXIF}DateTimeDigitized`,\n);\n\n/**\n * A user comment (`exif:UserComment`). A language alternative; reads the item in `language` (default `x-default`).\n *\n * @since 0.1.0\n * @category getters\n */\nexport const userComment: (self: Metadata.Metadata, language?: string) => Option.Option<string> =\n  Accessors.localized(`${EXIF}UserComment`);\n\n/**\n * Sets a user comment (`exif:UserComment`).\n *\n * @since 0.1.0\n * @category setters\n */\nexport const setUserComment: Metadata.LocalizedSetter = Accessors.setLocalized(\n  `${EXIF}UserComment`,\n);\n\n/**\n * The valid image width, in pixels (`exif:PixelXDimension`). An integer.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const pixelXDimension: (self: Metadata.Metadata) => Option.Option<number> =\n  Accessors.integer(`${EXIF}PixelXDimension`);\n\n/**\n * Sets the valid image width, in pixels (`exif:PixelXDimension`).\n *\n * @since 0.1.0\n * @category setters\n */\nexport const setPixelXDimension: Metadata.Setter<number> = Accessors.setInteger(\n  `${EXIF}PixelXDimension`,\n);\n\n/**\n * The valid image height, in pixels (`exif:PixelYDimension`). An integer.\n *\n * @since 0.1.0\n * @category getters\n */\nexport const pixelYDimension: (self: Metadata.Metadata) => Option.Option<number> =\n  Accessors.integer(`${EXIF}PixelYDimension`);\n\n/**\n * Sets the valid image height, in pixels (`exif:PixelYDimension`).\n *\n * @since 0.1.0\n * @category setters\n */\nexport const setPixelYDimension: Metadata.Setter<number> = Accessors.setInteger(\n  `${EXIF}PixelYDimension`,\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,mBAAuEA,KAClF,GAAG,KAAK,iBACV;;;;;;;AAQA,MAAa,sBAAmEC,QAC9E,GAAG,KAAK,iBACV;;;;;;;AAQA,MAAa,oBAAwED,KACnF,GAAG,KAAK,kBACV;;;;;;;AAQA,MAAa,uBAAoEC,QAC/E,GAAG,KAAK,kBACV;;;;;;;AAQA,MAAa,cACXC,UAAoB,GAAG,KAAK,YAAY;;;;;;;AAQ1C,MAAa,iBAA2CC,aACtD,GAAG,KAAK,YACV;;;;;;;AAQA,MAAa,kBACXC,QAAkB,GAAG,KAAK,gBAAgB;;;;;;;AAQ5C,MAAa,qBAA8CC,WACzD,GAAG,KAAK,gBACV;;;;;;;AAQA,MAAa,kBACXD,QAAkB,GAAG,KAAK,gBAAgB;;;;;;;AAQ5C,MAAa,qBAA8CC,WACzD,GAAG,KAAK,gBACV"}

package/dist/Expression-BIMMvduQ.mjs

@@ -0,0 +1,230 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { K as isTriple, P as isDefaultGraph, T as blankNode, q as isVariable, rt as triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { C as orderCompare, S as negate, b as fail, c as registry, d as TRUE, f as arithmetic, h as compareLiterals, i as cast, l as EvalFailure, m as catchEvalFailure, p as bool, r as builtIns, s as isCast, t as ExpressionError, u as FALSE, v as ebv, x as isNumeric, y as equals$1 } from "./Functions-AvjNcId_.mjs";
+import * as Arr from "effect/Array";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as DateTime from "effect/DateTime";
+import * as Random from "effect/Random";
+// src/sparql/Expression.ts
+/**
+* Evaluation of SPARQL expressions over solution mappings: all operators and
+* functional forms (`&&`, `||`, `!`, `IN`, `IF`, `COALESCE`, `BOUND`,
+* `EXISTS`), the built-in functions of SPARQL 1.1 and 1.2, XSD casts and
+* extension functions, with SPARQL's error semantics.
+*
+* Also exports the effective boolean value, value equality / ordering and
+* the `ORDER BY` term ordering.
+*
+* @since 0.1.0
+*/
+var Expression_exports = /* @__PURE__ */ __exportAll({
+	compare: () => compare,
+	effectiveBooleanValue: () => effectiveBooleanValue,
+	equals: () => equals,
+	evaluate: () => evaluate,
+	evaluateOrUndefined: () => evaluateOrUndefined,
+	evaluateUnsafe: () => evaluateUnsafe,
+	makeContext: () => makeContext,
+	test: () => test
+});
+/**
+* Creates an evaluation context.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeContext = (options) => {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	let counter = 0;
+	const defaultRandom = Random.Random.defaultValue();
+	const prefix = `e${Math.floor(defaultRandom.nextDoubleUnsafe() * 16777215).toString(36)}_`;
+	return {
+		now: options?.now ?? DateTime.toDateUtc(DateTime.nowUnsafe()),
+		baseIri: options?.baseIri,
+		functions: options?.functions ?? registry({}),
+		random: options?.random ?? (() => defaultRandom.nextDoubleUnsafe()),
+		blankNode: (label, solution) => {
+			if (label === void 0) return blankNode(`${prefix}${counter++}`);
+			const row = solution.origin ?? solution;
+			let scope = scopes.get(row);
+			if (scope === void 0) scopes.set(row, scope = MutableHashMap.empty());
+			const existing = MutableHashMap.get(scope, label);
+			if (Option.isSome(existing)) return existing.value;
+			const node = blankNode(`${prefix}${counter++}`);
+			MutableHashMap.set(scope, label, node);
+			return node;
+		}
+	};
+};
+/**
+* A term with its variables replaced by their bindings. Plain branches rather
+* than `Match`: it runs for every variable of every evaluated expression.
+*/
+const substitute = (t, solution) => {
+	if (isVariable(t)) return solution.map.get(t.value) ?? fail(`Unbound variable ?${t.value}`);
+	if (isTriple(t)) return triple(substitute(t.subject, solution), substitute(t.predicate, solution), substitute(t.object, solution));
+	if (isDefaultGraph(t)) return fail("Invalid term");
+	return t;
+};
+/**
+* Evaluates an expression; throws `EvalFailure` on errors. Plain branches
+* rather than `Match`: it runs once per expression node per solution.
+*
+* @internal
+*/
+const evaluateUnsafe = (e, solution, ctx) => {
+	if (Predicate.isTagged(e, "Operation")) return operation(e, solution, ctx);
+	if (isVariable(e) || isTriple(e)) return substitute(e, solution);
+	if (Predicate.isTagged(e, "FunctionCall")) return functionCall(e, solution, ctx);
+	if (Predicate.isTagged(e, "Exists")) {
+		if (ctx.exists === void 0) return fail("EXISTS is not supported here");
+		const r = ctx.exists(e, solution);
+		return bool(e.negated ? !r : r);
+	}
+	return e;
+};
+const functionCall = (call, solution, ctx) => {
+	const iri = call.function.value;
+	const args = call.args.map((a) => evaluateUnsafe(a, solution, ctx));
+	const f = ctx.functions.get(iri);
+	if (f !== void 0) return f(args, ctx);
+	if (isCast(iri)) {
+		const [arg, ...rest] = args;
+		if (arg === void 0 || Arr.isReadonlyArrayNonEmpty(rest)) return fail("Casts take one argument");
+		return cast(iri, arg);
+	}
+	return fail(`Unknown function <${iri}>`);
+};
+const ebvOf = (e, solution, ctx) => ebv(evaluateUnsafe(e, solution, ctx));
+const toError = (failure) => new ExpressionError({ message: failure.message });
+const attempt = (f) => Result.merge(catchEvalFailure(f));
+/** Argument `i` of an operation (the parser checked each operator's arity). */
+const argAt = (e, i) => e.args[i] ?? fail(`${e.operator} is missing argument ${i + 1}`);
+/** Evaluates argument `i` of an operation. */
+const argOf = (e, i, solution, ctx) => evaluateUnsafe(argAt(e, i), solution, ctx);
+const or = (e, solution, ctx) => {
+	const a = attempt(() => ebvOf(argAt(e, 0), solution, ctx));
+	if (a === true) return TRUE;
+	if (ebvOf(argAt(e, 1), solution, ctx)) return TRUE;
+	if (a instanceof EvalFailure) throw a;
+	return FALSE;
+};
+const and = (e, solution, ctx) => {
+	const a = attempt(() => ebvOf(argAt(e, 0), solution, ctx));
+	if (a === false) return FALSE;
+	if (!ebvOf(argAt(e, 1), solution, ctx)) return FALSE;
+	if (a instanceof EvalFailure) throw a;
+	return TRUE;
+};
+const order = (op, e, solution, ctx) => {
+	const a = argOf(e, 0, solution, ctx);
+	const b = argOf(e, 1, solution, ctx);
+	if (!isLiteral(a) || !isLiteral(b)) return fail("Cannot order non-literals");
+	const c = compareLiterals(a, b);
+	if (Number.isNaN(c)) return FALSE;
+	return bool(op === "<" ? c < 0 : op === ">" ? c > 0 : op === "<=" ? c <= 0 : c >= 0);
+};
+const isIn = (e, solution, ctx, negated) => {
+	const value = argOf(e, 0, solution, ctx);
+	let failure = Option.none();
+	if (e.args.some((x, i) => {
+		if (i === 0) return false;
+		const r = attempt(() => equals$1(value, evaluateUnsafe(x, solution, ctx)));
+		if (r instanceof EvalFailure) failure = Option.some(r);
+		return r === true;
+	})) return bool(!negated);
+	if (Option.isSome(failure)) throw failure.value;
+	return bool(negated);
+};
+const coalesce = (e, solution, ctx) => {
+	let value = Option.none();
+	e.args.some((x) => {
+		const r = attempt(() => evaluateUnsafe(x, solution, ctx));
+		if (r instanceof EvalFailure) return false;
+		value = Option.some(r);
+		return true;
+	});
+	return Option.isSome(value) ? value.value : fail("COALESCE: no argument could be evaluated");
+};
+const builtIn = (op, e, solution, ctx) => {
+	const f = builtIns[op];
+	if (f === void 0) return fail(`Unsupported operator ${op}`);
+	return f(e.args.map((a) => evaluateUnsafe(a, solution, ctx)), ctx, solution);
+};
+/**
+* Evaluates an operation, by operator. Plain branches rather than `Match`:
+* it runs once per operation per solution.
+*/
+const operation = (e, solution, ctx) => {
+	const op = e.operator;
+	if (op === "||") return or(e, solution, ctx);
+	if (op === "&&") return and(e, solution, ctx);
+	if (op === "=") return bool(equals$1(argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx)));
+	if (op === "!=") return bool(!equals$1(argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx)));
+	if (op === "<" || op === ">" || op === "<=" || op === ">=") return order(op, e, solution, ctx);
+	if (op === "!") return bool(!ebvOf(argAt(e, 0), solution, ctx));
+	if (op === "+" || op === "-" || op === "*" || op === "/") return arithmetic(op, argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx));
+	if (op === "UPLUS") {
+		const a = argOf(e, 0, solution, ctx);
+		return isNumeric(a) ? a : fail("Unary plus of a non-numeric");
+	}
+	if (op === "UMINUS") return negate(argOf(e, 0, solution, ctx));
+	if (op === "IN" || op === "NOT IN") return isIn(e, solution, ctx, op === "NOT IN");
+	if (op === "BOUND") {
+		const v = e.args[0];
+		return bool(isVariable(v) && solution.map.has(v.value));
+	}
+	if (op === "IF") return ebvOf(argAt(e, 0), solution, ctx) ? argOf(e, 1, solution, ctx) : argOf(e, 2, solution, ctx);
+	if (op === "COALESCE") return coalesce(e, solution, ctx);
+	return builtIn(op, e, solution, ctx);
+};
+/**
+* Evaluates an expression against a solution.
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const evaluate = (expression, solution, context) => Result.mapError(catchEvalFailure(() => evaluateUnsafe(expression, solution, context)), toError);
+/**
+* Evaluates an expression, returning `undefined` on errors.
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const evaluateOrUndefined = (expression, solution, context) => Result.getOrUndefined(catchEvalFailure(() => evaluateUnsafe(expression, solution, context)));
+/**
+* Evaluates a filter condition: the effective boolean value of the
+* expression, with errors counting as `false`.
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const test = (expression, solution, context) => Result.getOrElse(catchEvalFailure(() => ebv(evaluateUnsafe(expression, solution, context))), () => false);
+/**
+* The effective boolean value of a term (SPARQL 1.1 §17.2.2).
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const effectiveBooleanValue = (term) => Result.mapError(catchEvalFailure(() => ebv(term)), toError);
+/**
+* Value equality (the `=` operator). Fails for incomparable literals.
+*
+* @since 0.1.0
+* @category evaluation
+*/
+const equals = (a, b) => Result.mapError(catchEvalFailure(() => equals$1(a, b)), toError);
+/**
+* The total order on (possibly unbound) terms used by `ORDER BY`: unbound <
+* blank nodes < IRIs < literals < triple terms.
+*
+* @since 0.1.0
+* @category ordering
+*/
+const compare = (a, b) => orderCompare(Option.fromUndefinedOr(a), Option.fromUndefinedOr(b));
+export { evaluate as a, makeContext as c, equals as i, test as l, compare as n, evaluateOrUndefined as o, effectiveBooleanValue as r, evaluateUnsafe as s, Expression_exports as t };
+
+//# sourceMappingURL=Expression-BIMMvduQ.mjs.map

package/dist/Expression-BIMMvduQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression-BIMMvduQ.mjs","names":["Functions.registry","Term.blankNode","Term.isVariable","V.fail","Term.isTriple","Term.triple","Term.isDefaultGraph","V.bool","Functions.isCast","Functions.cast","V.ebv","Functions.ExpressionError","V.catchEvalFailure","V.TRUE","V.EvalFailure","V.FALSE","Term.isLiteral","V.compareLiterals","V.equals","Functions.builtIns","V.arithmetic","V.isNumeric","V.negate","V.orderCompare"],"sources":["../src/sparql/Expression.ts"],"sourcesContent":["/**\n * Evaluation of SPARQL expressions over solution mappings: all operators and\n * functional forms (`&&`, `||`, `!`, `IN`, `IF`, `COALESCE`, `BOUND`,\n * `EXISTS`), the built-in functions of SPARQL 1.1 and 1.2, XSD casts and\n * extension functions, with SPARQL's error semantics.\n *\n * Also exports the effective boolean value, value equality / ordering and\n * the `ORDER BY` term ordering.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as DateTime from 'effect/DateTime';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Random from 'effect/Random';\nimport * as Result from 'effect/Result';\nimport * as Term from '../Term.ts';\nimport type * as Algebra from './Algebra.ts';\nimport type * as Ast from './Ast.ts';\nimport type { Bindings } from './Bindings.ts';\nimport * as Functions from './Functions.ts';\nimport * as V from './internal/values.ts';\n\n/**\n * The context of expression evaluation.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Context extends Functions.FunctionContext {\n  /** Extension functions by IRI. */\n  readonly functions: Functions.Registry;\n  /**\n   * Evaluates an `EXISTS` pattern for a solution. The engine precomputes\n   * these (pattern evaluation is effectful) before evaluating the\n   * expression; without it `EXISTS` is an error.\n   */\n  readonly exists?: ((e: Algebra.ExistsExpression, solution: Bindings) => boolean) | undefined;\n}\n\n/**\n * Creates an evaluation context.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeContext = (options?: {\n  readonly now?: Date | undefined;\n  readonly baseIri?: string | undefined;\n  readonly functions?: Functions.Registry | undefined;\n  readonly random?: (() => number) | undefined;\n}): Context => {\n  const scopes = new WeakMap<Bindings, MutableHashMap.MutableHashMap<string, Term.BlankNode>>();\n  let counter = 0;\n  // A plain constructor, outside any Effect: the defaults are the default\n  // `Random` service (`Math.random`) and the current time.\n  const defaultRandom = Random.Random.defaultValue();\n  const prefix = `e${Math.floor(defaultRandom.nextDoubleUnsafe() * 0xffffff).toString(36)}_`;\n  return {\n    now: options?.now ?? DateTime.toDateUtc(DateTime.nowUnsafe()),\n    baseIri: options?.baseIri,\n    functions: options?.functions ?? Functions.registry({}),\n    random: options?.random ?? (() => defaultRandom.nextDoubleUnsafe()),\n    blankNode: (label, solution) => {\n      if (label === undefined) return Term.blankNode(`${prefix}${counter++}`);\n      const row = solution.origin ?? solution;\n      let scope = scopes.get(row);\n      if (scope === undefined) scopes.set(row, (scope = MutableHashMap.empty()));\n      const existing = MutableHashMap.get(scope, label);\n      if (Option.isSome(existing)) return existing.value;\n      const node = Term.blankNode(`${prefix}${counter++}`);\n      MutableHashMap.set(scope, label, node);\n      return node;\n    },\n  };\n};\n\n/**\n * A term with its variables replaced by their bindings. Plain branches rather\n * than `Match`: it runs for every variable of every evaluated expression.\n */\nconst substitute = (t: Term.Term, solution: Bindings): Term.GroundTerm => {\n  if (Term.isVariable(t))\n    return solution.map.get(t.value) ?? V.fail(`Unbound variable ?${t.value}`);\n  if (Term.isTriple(t)) {\n    // Substitution keeps each position's kind for the ground terms a pattern can be bound to;\n    // like the triple patterns it comes from, the result is not checked again.\n    return Term.triple<any, any, any>(\n      substitute(t.subject, solution),\n      substitute(t.predicate, solution),\n      substitute(t.object, solution),\n    );\n  }\n  if (Term.isDefaultGraph(t)) return V.fail('Invalid term');\n  return t;\n};\n\n/**\n * Evaluates an expression; throws `EvalFailure` on errors. Plain branches\n * rather than `Match`: it runs once per expression node per solution.\n *\n * @internal\n */\nexport const evaluateUnsafe = (\n  e: Algebra.Expression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  if (Predicate.isTagged(e, 'Operation')) return operation(e, solution, ctx);\n  if (Term.isVariable(e) || Term.isTriple(e)) return substitute(e, solution);\n  if (Predicate.isTagged(e, 'FunctionCall')) return functionCall(e, solution, ctx);\n  if (Predicate.isTagged(e, 'Exists')) {\n    if (ctx.exists === undefined) return V.fail('EXISTS is not supported here');\n    const r = ctx.exists(e, solution);\n    return V.bool(e.negated ? !r : r);\n  }\n  return e;\n};\n\nconst functionCall = (\n  call: Algebra.FunctionCallExpression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  const iri = call.function.value;\n  const args = call.args.map((a) => evaluateUnsafe(a, solution, ctx));\n  const f = ctx.functions.get(iri);\n  if (f !== undefined) return f(args, ctx);\n  if (Functions.isCast(iri)) {\n    const [arg, ...rest] = args;\n    if (arg === undefined || Arr.isReadonlyArrayNonEmpty(rest)) {\n      return V.fail('Casts take one argument');\n    }\n    return Functions.cast(iri, arg);\n  }\n  return V.fail(`Unknown function <${iri}>`);\n};\n\nconst ebvOf = (e: Algebra.Expression, solution: Bindings, ctx: Context): boolean =>\n  V.ebv(evaluateUnsafe(e, solution, ctx));\n\nconst toError = (failure: V.EvalFailure): Functions.ExpressionError =>\n  new Functions.ExpressionError({ message: failure.message });\n\nconst attempt = <A>(f: () => A): A | V.EvalFailure => Result.merge(V.catchEvalFailure(f));\n\n/** Argument `i` of an operation (the parser checked each operator's arity). */\nconst argAt = (e: Algebra.OperationExpression, i: number): Algebra.Expression =>\n  e.args[i] ?? V.fail(`${e.operator} is missing argument ${i + 1}`);\n\n/** Evaluates argument `i` of an operation. */\nconst argOf = (e: Algebra.OperationExpression, i: number, solution: Bindings, ctx: Context) =>\n  evaluateUnsafe(argAt(e, i), solution, ctx);\n\nconst or = (e: Algebra.OperationExpression, solution: Bindings, ctx: Context): Term.GroundTerm => {\n  const a = attempt(() => ebvOf(argAt(e, 0), solution, ctx));\n  if (a === true) return V.TRUE;\n  const b = ebvOf(argAt(e, 1), solution, ctx);\n  if (b) return V.TRUE;\n  if (a instanceof V.EvalFailure) throw a;\n  return V.FALSE;\n};\n\nconst and = (e: Algebra.OperationExpression, solution: Bindings, ctx: Context): Term.GroundTerm => {\n  const a = attempt(() => ebvOf(argAt(e, 0), solution, ctx));\n  if (a === false) return V.FALSE;\n  const b = ebvOf(argAt(e, 1), solution, ctx);\n  if (!b) return V.FALSE;\n  if (a instanceof V.EvalFailure) throw a;\n  return V.TRUE;\n};\n\nconst order = (\n  op: '<' | '>' | '<=' | '>=',\n  e: Algebra.OperationExpression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  const a = argOf(e, 0, solution, ctx);\n  const b = argOf(e, 1, solution, ctx);\n  if (!Term.isLiteral(a) || !Term.isLiteral(b)) return V.fail('Cannot order non-literals');\n  const c = V.compareLiterals(a, b);\n  if (Number.isNaN(c)) return V.FALSE;\n  return V.bool(op === '<' ? c < 0 : op === '>' ? c > 0 : op === '<=' ? c <= 0 : c >= 0);\n};\n\nconst isIn = (\n  e: Algebra.OperationExpression,\n  solution: Bindings,\n  ctx: Context,\n  negated: boolean,\n): Term.GroundTerm => {\n  const value = argOf(e, 0, solution, ctx);\n  let failure = Option.none<V.EvalFailure>();\n  const found = e.args.some((x, i) => {\n    if (i === 0) return false;\n    const r = attempt(() => V.equals(value, evaluateUnsafe(x, solution, ctx)));\n    if (r instanceof V.EvalFailure) failure = Option.some(r);\n    return r === true;\n  });\n  if (found) return V.bool(!negated);\n  if (Option.isSome(failure)) throw failure.value;\n  return V.bool(negated);\n};\n\nconst coalesce = (\n  e: Algebra.OperationExpression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  let value = Option.none<Term.GroundTerm>();\n  e.args.some((x) => {\n    const r = attempt(() => evaluateUnsafe(x, solution, ctx));\n    if (r instanceof V.EvalFailure) return false;\n    value = Option.some(r);\n    return true;\n  });\n  return Option.isSome(value) ? value.value : V.fail('COALESCE: no argument could be evaluated');\n};\n\nconst builtIn = (\n  op: Ast.BuiltInName,\n  e: Algebra.OperationExpression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  const f = Functions.builtIns[op];\n  if (f === undefined) return V.fail(`Unsupported operator ${op}`);\n  const values = e.args.map((a) => evaluateUnsafe(a, solution, ctx));\n  // SAFETY: `BuiltInArgs` types the first three slots as present; each built-in checks its own\n  // arity before reading them.\n  return f(values as unknown as Functions.BuiltInArgs, ctx, solution);\n};\n\n/**\n * Evaluates an operation, by operator. Plain branches rather than `Match`:\n * it runs once per operation per solution.\n */\nconst operation = (\n  e: Algebra.OperationExpression,\n  solution: Bindings,\n  ctx: Context,\n): Term.GroundTerm => {\n  const op = e.operator;\n  if (op === '||') return or(e, solution, ctx);\n  if (op === '&&') return and(e, solution, ctx);\n  if (op === '=') return V.bool(V.equals(argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx)));\n  if (op === '!=') {\n    return V.bool(!V.equals(argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx)));\n  }\n  if (op === '<' || op === '>' || op === '<=' || op === '>=') return order(op, e, solution, ctx);\n  if (op === '!') return V.bool(!ebvOf(argAt(e, 0), solution, ctx));\n  if (op === '+' || op === '-' || op === '*' || op === '/') {\n    return V.arithmetic(op, argOf(e, 0, solution, ctx), argOf(e, 1, solution, ctx));\n  }\n  if (op === 'UPLUS') {\n    const a = argOf(e, 0, solution, ctx);\n    return V.isNumeric(a) ? a : V.fail('Unary plus of a non-numeric');\n  }\n  if (op === 'UMINUS') return V.negate(argOf(e, 0, solution, ctx));\n  if (op === 'IN' || op === 'NOT IN') return isIn(e, solution, ctx, op === 'NOT IN');\n  if (op === 'BOUND') {\n    const v = e.args[0];\n    return V.bool(Term.isVariable(v) && solution.map.has(v.value));\n  }\n  if (op === 'IF') {\n    return ebvOf(argAt(e, 0), solution, ctx)\n      ? argOf(e, 1, solution, ctx)\n      : argOf(e, 2, solution, ctx);\n  }\n  if (op === 'COALESCE') return coalesce(e, solution, ctx);\n  return builtIn(op, e, solution, ctx);\n};\n\n/**\n * Evaluates an expression against a solution.\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const evaluate = (\n  expression: Algebra.Expression,\n  solution: Bindings,\n  context: Context,\n): Result.Result<Term.GroundTerm, Functions.ExpressionError> =>\n  Result.mapError(\n    V.catchEvalFailure(() => evaluateUnsafe(expression, solution, context)),\n    toError,\n  );\n\n/**\n * Evaluates an expression, returning `undefined` on errors.\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const evaluateOrUndefined = (\n  expression: Algebra.Expression,\n  solution: Bindings,\n  context: Context,\n): Term.GroundTerm | undefined =>\n  Result.getOrUndefined(V.catchEvalFailure(() => evaluateUnsafe(expression, solution, context)));\n\n/**\n * Evaluates a filter condition: the effective boolean value of the\n * expression, with errors counting as `false`.\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const test = (\n  expression: Algebra.Expression,\n  solution: Bindings,\n  context: Context,\n): boolean =>\n  Result.getOrElse(\n    V.catchEvalFailure(() => V.ebv(evaluateUnsafe(expression, solution, context))),\n    () => false,\n  );\n\n/**\n * The effective boolean value of a term (SPARQL 1.1 §17.2.2).\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const effectiveBooleanValue = (\n  term: Term.GroundTerm,\n): Result.Result<boolean, Functions.ExpressionError> =>\n  Result.mapError(\n    V.catchEvalFailure(() => V.ebv(term)),\n    toError,\n  );\n\n/**\n * Value equality (the `=` operator). Fails for incomparable literals.\n *\n * @since 0.1.0\n * @category evaluation\n */\nexport const equals = (\n  a: Term.GroundTerm,\n  b: Term.GroundTerm,\n): Result.Result<boolean, Functions.ExpressionError> =>\n  Result.mapError(\n    V.catchEvalFailure(() => V.equals(a, b)),\n    toError,\n  );\n\n/**\n * The total order on (possibly unbound) terms used by `ORDER BY`: unbound <\n * blank nodes < IRIs < literals < triple terms.\n *\n * @since 0.1.0\n * @category ordering\n */\nexport const compare = (a: Term.GroundTerm | undefined, b: Term.GroundTerm | undefined): number =>\n  V.orderCompare(Option.fromUndefinedOr(a), Option.fromUndefinedOr(b));\n"],"mappings":"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"}

package/dist/Expression-W8A9cyX7.d.mts

@@ -0,0 +1,89 @@
+import { s as GroundTerm } from "./Term-B_4ezyXq.mjs";
+import { t as Bindings } from "./Bindings-DiKpBd7f.mjs";
+import { a as ExistsExpression, o as Expression } from "./Algebra-uGsIEOUA.mjs";
+import { a as FunctionContext, r as ExpressionError, s as Registry } from "./Functions-OQJZP-F6.mjs";
+import * as Result from "effect/Result";
+declare namespace Expression_d_exports {
+  export { Context, compare, effectiveBooleanValue, equals, evaluate, evaluateOrUndefined, evaluateUnsafe, makeContext, test };
+}
+/**
+ * The context of expression evaluation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Context extends FunctionContext {
+  /** Extension functions by IRI. */
+  readonly functions: Registry;
+  /**
+   * Evaluates an `EXISTS` pattern for a solution. The engine precomputes
+   * these (pattern evaluation is effectful) before evaluating the
+   * expression; without it `EXISTS` is an error.
+   */
+  readonly exists?: ((e: ExistsExpression, solution: Bindings) => boolean) | undefined;
+}
+/**
+ * Creates an evaluation context.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeContext: (options?: {
+  readonly now?: Date | undefined;
+  readonly baseIri?: string | undefined;
+  readonly functions?: Registry | undefined;
+  readonly random?: (() => number) | undefined;
+}) => Context;
+/**
+ * Evaluates an expression; throws `EvalFailure` on errors. Plain branches
+ * rather than `Match`: it runs once per expression node per solution.
+ *
+ * @internal
+ */
+declare const evaluateUnsafe: (e: Expression, solution: Bindings, ctx: Context) => GroundTerm;
+/**
+ * Evaluates an expression against a solution.
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const evaluate: (expression: Expression, solution: Bindings, context: Context) => Result.Result<GroundTerm, ExpressionError>;
+/**
+ * Evaluates an expression, returning `undefined` on errors.
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const evaluateOrUndefined: (expression: Expression, solution: Bindings, context: Context) => GroundTerm | undefined;
+/**
+ * Evaluates a filter condition: the effective boolean value of the
+ * expression, with errors counting as `false`.
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const test: (expression: Expression, solution: Bindings, context: Context) => boolean;
+/**
+ * The effective boolean value of a term (SPARQL 1.1 §17.2.2).
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const effectiveBooleanValue: (term: GroundTerm) => Result.Result<boolean, ExpressionError>;
+/**
+ * Value equality (the `=` operator). Fails for incomparable literals.
+ *
+ * @since 0.1.0
+ * @category evaluation
+ */
+declare const equals: (a: GroundTerm, b: GroundTerm) => Result.Result<boolean, ExpressionError>;
+/**
+ * The total order on (possibly unbound) terms used by `ORDER BY`: unbound <
+ * blank nodes < IRIs < literals < triple terms.
+ *
+ * @since 0.1.0
+ * @category ordering
+ */
+declare const compare: (a: GroundTerm | undefined, b: GroundTerm | undefined) => number;
+export { equals as a, evaluateUnsafe as c, effectiveBooleanValue as i, makeContext as l, Expression_d_exports as n, evaluate as o, compare as r, evaluateOrUndefined as s, Context as t, test as u };
+//# sourceMappingURL=Expression-W8A9cyX7.d.mts.map