@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.js

@@ -1,46 +0,0 @@
-import { Either, Left } from "purify-ts";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST LiteralType using some heuristics.
- */
-export function transformShapeToAstLiteralType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        const literalDefaultValue = shapeStack.defaultValue.filter((term) => term.termType === "Literal");
-        const literalHasValues = shapeStack.constraints.hasValues.filter((term) => term.termType === "Literal");
-        const literalIn = shapeStack.constraints.in_.filter((term) => term.termType === "Literal");
-        const nodeKinds = propertyShapeNodeKinds(shape);
-        if ([
-            // Treat any shape with the constraints in the list as a literal type
-            shape.constraints.datatype,
-            shape.constraints.maxExclusive,
-            shape.constraints.maxInclusive,
-            shape.constraints.minExclusive,
-            shape.constraints.minInclusive,
-        ].some((constraint) => constraint.isJust()) ||
-            shape.constraints.languageIn.length > 0 ||
-            literalDefaultValue.isJust() ||
-            literalHasValues.length > 0 ||
-            literalIn.length > 0 ||
-            // Treat any shape with a single sh:nodeKind of sh:Literal as a literal type
-            (nodeKinds.size === 1 && nodeKinds.has("Literal")))
-            return Either.of({
-                datatype: shape.constraints.datatype,
-                defaultValue: literalDefaultValue,
-                hasValues: literalHasValues,
-                in_: literalIn,
-                kind: "LiteralType",
-                languageIn: [...new Set(shape.constraints.languageIn)],
-                maxExclusive: shape.constraints.maxExclusive,
-                maxInclusive: shape.constraints.maxInclusive,
-                minExclusive: shape.constraints.minExclusive,
-                minInclusive: shape.constraints.minInclusive,
-                nodeKinds: new Set(["Literal"]),
-            });
-        return Left(new Error(`unable to transform ${shape} into an AST type`));
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-//# sourceMappingURL=transformShapeToAstLiteralType.js.map

package/dist/ast/CompositeType.d.ts

@@ -1,13 +0,0 @@
-import type { Type } from "./Type.js";
-/**
- * A composite of types, such as an intersection or union.
- */
-export interface CompositeType<MemberTypeT extends Type> {
-    /**
-     * Member types.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    readonly memberTypes: MemberTypeT[];
-}
-//# sourceMappingURL=CompositeType.d.ts.map

package/dist/ast/CompositeType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=CompositeType.js.map

package/dist/ast/Name.d.ts

@@ -1,49 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { Curie } from "./Curie.js";
-export interface Name {
-    readonly identifier: BlankNode | (NamedNode & {
-        /**
-         * Compact URI (CURIE).
-         */
-        readonly curie: Maybe<Curie>;
-        /**
-         * Unique unqualified/local identifier, derived from the CURIE.
-         *
-         * Returns Just if the local identifier is unique across all CURIEs, otherwise Nothing.
-         */
-        readonly uniqueLocalPart: () => Maybe<string>;
-    });
-    /**
-     * rdfs:label.
-     */
-    readonly label: Maybe<string>;
-    /**
-     * sh:path for property shapes.
-     */
-    readonly propertyPath: Maybe<NamedNode & {
-        /**
-         * Compact URI (CURIE).
-         */
-        readonly curie: Maybe<Curie>;
-        /**
-         * Unique unqualified/local identifier, derived from the CURIE.
-         *
-         * Returns Just if the local identifier is unique across all CURIEs, otherwise Nothing.
-         */
-        readonly uniqueLocalPart: () => Maybe<string>;
-    }>;
-    /**
-     * sh:name.
-     */
-    readonly shName: Maybe<string>;
-    /**
-     * shaclmate:name.
-     */
-    readonly shaclmateName: Maybe<string>;
-    /**
-     * Synthesized in code.
-     */
-    readonly syntheticName: Maybe<string>;
-}
-//# sourceMappingURL=Name.d.ts.map

package/dist/ast/Name.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Name.js.map

package/dist/ast/ObjectCompositeType.d.ts

@@ -1,33 +0,0 @@
-import type { Maybe } from "purify-ts";
-import type { TsFeature } from "../enums/TsFeature.js";
-import type { CompositeType } from "./CompositeType.js";
-import type { Name } from "./Name.js";
-import type { ObjectType } from "./ObjectType.js";
-/**
- * A composite of object types, such as an intersection or union.
- */
-export interface ObjectCompositeType extends CompositeType<ObjectType> {
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    readonly comment: Maybe<string>;
-    /**
-     * Should generated code derived from this type be visible outside its module?
-     *
-     * Defaults to true.
-     */
-    readonly export: boolean;
-    /**
-     * Human-readable label from rdfs:label.
-     */
-    readonly label: Maybe<string>;
-    /**
-     * Name of this type, usually derived from sh:name or shaclmate:name.
-     */
-    readonly name: Name;
-    /**
-     * TypeScript features to generate.
-     */
-    readonly tsFeatures: Set<TsFeature>;
-}
-//# sourceMappingURL=ObjectCompositeType.d.ts.map

package/dist/ast/ObjectCompositeType.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ObjectCompositeType.js.map

package/dist/generators/ts/DeclaredType.d.ts

@@ -1,17 +0,0 @@
-import type { ClassDeclarationStructure, InterfaceDeclarationStructure, ModuleDeclarationStructure, TypeAliasDeclarationStructure } from "ts-morph";
-import type { TsFeature } from "../../enums/index.js";
-import type { Import } from "./Import.js";
-import { Type } from "./Type.js";
-export declare abstract class DeclaredType extends Type {
-    abstract readonly declarationImports: readonly Import[];
-    abstract readonly declarations: readonly (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure | TypeAliasDeclarationStructure)[];
-    readonly export: boolean;
-    readonly features: Set<TsFeature>;
-    readonly name: string;
-    constructor({ export_, features, name, }: {
-        export_: boolean;
-        features: Set<TsFeature>;
-        name: string;
-    });
-}
-//# sourceMappingURL=DeclaredType.d.ts.map

package/dist/generators/ts/DeclaredType.js

@@ -1,13 +0,0 @@
-import { Type } from "./Type.js";
-export class DeclaredType extends Type {
-    export;
-    features;
-    name;
-    constructor({ export_, features, name, }) {
-        super();
-        this.export = export_;
-        this.features = features;
-        this.name = name;
-    }
-}
-//# sourceMappingURL=DeclaredType.js.map

package/dist/generators/ts/Import.d.ts

@@ -1,20 +0,0 @@
-import { type ImportDeclarationStructure } from "ts-morph";
-export type Import = ImportDeclarationStructure | string;
-/**
- * Singleton values for common imports.
- */
-export declare namespace Import {
-    const DATA_FACTORY: Import;
-    const DATASET_FACTORY: Import;
-    const GRAPHQL: Import;
-    const GRAPHQL_SCALARS: Import;
-    const PURIFY: Import;
-    const RDF_LITERAL: Import;
-    const RDFJS_RESOURCE: Import;
-    const RDFJS_TYPES: Import;
-    const SHA256: Import;
-    const SPARQLJS: Import;
-    const UUID: Import;
-    const ZOD: Import;
-}
-//# sourceMappingURL=Import.d.ts.map

package/dist/generators/ts/Import.js

@@ -1,65 +0,0 @@
-import { StructureKind } from "ts-morph";
-/**
- * Singleton values for common imports.
- */
-export var Import;
-(function (Import) {
-    Import.DATA_FACTORY = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "n3",
-        namedImports: [{ alias: "dataFactory", name: "DataFactory" }],
-    };
-    Import.DATASET_FACTORY = "import { StoreFactory as _DatasetFactory } from 'n3'; const datasetFactory = new _DatasetFactory();";
-    Import.GRAPHQL = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql",
-        namespaceImport: "graphql",
-    };
-    Import.GRAPHQL_SCALARS = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "graphql-scalars",
-        namespaceImport: "graphqlScalars",
-    };
-    Import.PURIFY = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "purify-ts",
-        namespaceImport: "purify",
-    };
-    Import.RDF_LITERAL = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdf-literal",
-        namespaceImport: "rdfLiteral",
-    };
-    Import.RDFJS_RESOURCE = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "rdfjs-resource",
-        namespaceImport: "rdfjsResource",
-    };
-    Import.RDFJS_TYPES = {
-        isTypeOnly: true,
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@rdfjs/types",
-        namespaceImport: "rdfjs",
-    };
-    Import.SHA256 = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "js-sha256",
-        namedImports: ["sha256"],
-    };
-    Import.SPARQLJS = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "sparqljs",
-        namespaceImport: "sparqljs",
-    };
-    Import.UUID = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "uuid",
-        namespaceImport: "uuid",
-    };
-    Import.ZOD = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "zod",
-        namedImports: [{ alias: "zod", name: "z" }],
-    };
-})(Import || (Import = {}));
-//# sourceMappingURL=Import.js.map

package/dist/generators/ts/NumberType.d.ts

@@ -1,13 +0,0 @@
-import { PrimitiveType } from "./PrimitiveType.js";
-import type { TermType } from "./TermType.js";
-import type { Type } from "./Type.js";
-export declare abstract class NumberType extends PrimitiveType<number> {
-    readonly kind = "NumberType";
-    readonly typeof = "number";
-    get conversions(): readonly Type.Conversion[];
-    get name(): string;
-    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
-    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
-}
-//# sourceMappingURL=NumberType.d.ts.map

package/dist/generators/ts/NumberType.js

@@ -1,71 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Memoize } from "typescript-memoize";
-import { PrimitiveType } from "./PrimitiveType.js";
-import { objectInitializer } from "./objectInitializer.js";
-export class NumberType extends PrimitiveType {
-    kind = "NumberType";
-    typeof = "number";
-    get conversions() {
-        const conversions = [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
-                sourceTypeName: this.name,
-            },
-        ];
-        this.primitiveDefaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => defaultValue.toString(),
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-        });
-        return conversions;
-    }
-    get name() {
-        if (this.primitiveIn.length > 0) {
-            return this.primitiveIn.map((value) => value.toString()).join(" | ");
-        }
-        return this.typeof;
-    }
-    jsonZodSchema({ variables, }) {
-        switch (this.primitiveIn.length) {
-            case 0:
-                return `${variables.zod}.number()`;
-            case 1:
-                return `${variables.zod}.literal(${this.primitiveIn[0]})`;
-            default:
-                return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
-        }
-    }
-    fromRdfExpressionChain({ variables, }) {
-        let fromRdfResourceValueExpression = "value.toNumber()";
-        if (this.primitiveIn.length > 0) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case ${value}:`).join(" ")} return purify.Either.of${eitherTypeParameters}(value); default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
-        }
-        return {
-            ...super.fromRdfExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
-        };
-    }
-    toRdfExpression({ variables, }) {
-        return this.primitiveDefaultValue
-            .map((defaultValue) => `(${variables.value} !== ${defaultValue} ? [${variables.value}] : [])`)
-            .orDefault(`[${variables.value}]`);
-    }
-}
-__decorate([
-    Memoize()
-], NumberType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], NumberType.prototype, "name", null);
-//# sourceMappingURL=NumberType.js.map

package/dist/generators/ts/PrimitiveType.d.ts

@@ -1,21 +0,0 @@
-import { Maybe } from "purify-ts";
-import { LiteralType } from "./LiteralType.js";
-import { Type } from "./Type.js";
-export declare abstract class PrimitiveType<ValueT extends boolean | Date | string | number> extends LiteralType {
-    readonly equalsFunction: string;
-    readonly primitiveDefaultValue: Maybe<ValueT>;
-    readonly primitiveIn: readonly ValueT[];
-    constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }: {
-        primitiveDefaultValue: Maybe<ValueT>;
-        primitiveIn: readonly ValueT[];
-    } & ConstructorParameters<typeof LiteralType>[0]);
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get jsonName(): Type.JsonName;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    snippetDeclarations({ features, }: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<LiteralType["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-}
-//# sourceMappingURL=PrimitiveType.d.ts.map

package/dist/generators/ts/PrimitiveType.js

@@ -1,57 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { LiteralType } from "./LiteralType.js";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class PrimitiveType extends LiteralType {
-    equalsFunction = `${syntheticNamePrefix}strictEquals`;
-    primitiveDefaultValue;
-    primitiveIn;
-    constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
-        super(superParameters);
-        this.primitiveDefaultValue = primitiveDefaultValue;
-        this.primitiveIn = primitiveIn;
-    }
-    get discriminatorProperty() {
-        return Maybe.empty();
-    }
-    get jsonName() {
-        return new Type.JsonName(this.name);
-    }
-    fromJsonExpression({ variables, }) {
-        return variables.value;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.toString());`];
-    }
-    snippetDeclarations({ features, }) {
-        const snippetDeclarations = [];
-        if (features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.strictEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlWherePatterns(parameters) {
-        return super.sparqlWherePatterns({
-            ...parameters,
-            ignoreLiteralLanguage: parameters.ignoreLiteralLanguage ?? true,
-        });
-    }
-    toJsonExpression({ variables, }) {
-        return variables.value;
-    }
-}
-__decorate([
-    Memoize()
-], PrimitiveType.prototype, "jsonName", null);
-//# sourceMappingURL=PrimitiveType.js.map

package/dist/generators/ts/SnippetDeclarations.d.ts

@@ -1,17 +0,0 @@
-export declare namespace SnippetDeclarations {
-    const arrayEquals = "/**\n * Compare two arrays element-wise with the provided elementEquals function.\n */  \nexport function $arrayEquals<T>(\n  leftArray: readonly T[],\n  rightArray: readonly T[],\n  elementEquals: (left: T, right: T) => boolean | $EqualsResult,\n): $EqualsResult {\n  if (leftArray.length !== rightArray.length) {\n    return purify.Left({\n      left: leftArray,\n      right: rightArray,\n      type: \"ArrayLength\",\n    });\n  }\n\n  for (\n    let leftElementIndex = 0;\n    leftElementIndex < leftArray.length;\n    leftElementIndex++\n  ) {\n    const leftElement = leftArray[leftElementIndex];\n\n    const rightUnequals: $EqualsResult.Unequal[] = [];\n    for (\n      let rightElementIndex = 0;\n      rightElementIndex < rightArray.length;\n      rightElementIndex++\n    ) {\n      const rightElement = rightArray[rightElementIndex];\n\n      const leftElementEqualsRightElement =\n        $EqualsResult.fromBooleanEqualsResult(\n          leftElement,\n          rightElement,\n          elementEquals(leftElement, rightElement),\n        );\n      if (leftElementEqualsRightElement.isRight()) {\n        break; // left element === right element, break out of the right iteration\n      }\n      rightUnequals.push(\n        leftElementEqualsRightElement.extract() as $EqualsResult.Unequal,\n      );\n    }\n\n    if (rightUnequals.length === rightArray.length) {\n      // All right elements were unequal to the left element\n      return purify.Left({\n        left: {\n          array: leftArray,\n          element: leftElement,\n          elementIndex: leftElementIndex,\n        },\n        right: {\n          array: rightArray,\n          unequals: rightUnequals,\n        },\n        type: \"ArrayElement\",\n      });\n    }\n    // Else there was a right element equal to the left element, continue to the next left element\n  }\n\n  return $EqualsResult.Equal;\n}\n";
-    const arrayIntersection = "export function $arrayIntersection<T>(left: readonly T[], right: readonly T[]): readonly T[] {\n  if (left.length === 0) {\n    return right;\n  }\n  if (right.length === 0) {\n    return left;\n  }\n\n  const intersection = new Set<T>();\n  if (left.length <= right.length) {\n    const rightSet = new Set(right);\n    for (const leftElement of left) {\n      if (rightSet.has(leftElement)) {\n        intersection.add(leftElement);\n      }\n    }\n  } else {\n    const leftSet = new Set(left);\n    for (const rightElement of right) {\n      if (leftSet.has(rightElement)) {\n        intersection.add(rightElement);\n      }  \n    }\n  }\n  return [...intersection];\n}";
-    const booleanEquals = "/**\n * Compare two objects with equals(other: T): boolean methods and return an $EqualsResult.\n */\nexport function $booleanEquals<T extends { equals: (other: T) => boolean }>(\n  left: T,\n  right: T,\n): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.equals(right),\n  );\n}";
-    const dateEquals = "/**\n * Compare two Dates and return an $EqualsResult.\n */\nexport function $dateEquals(left: Date, right: Date): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.getTime() === right.getTime(),\n  );\n}";
-    const EqualsResult = "export type $EqualsResult = purify.Either<$EqualsResult.Unequal, true>;\n\nexport namespace $EqualsResult {\n  export const Equal: $EqualsResult = purify.Either.of<Unequal, true>(true);\n\n  export function fromBooleanEqualsResult(\n    left: any,\n    right: any,\n    equalsResult: boolean | $EqualsResult,\n  ): $EqualsResult {\n    if (typeof equalsResult !== \"boolean\") {\n      return equalsResult;\n    }\n\n    if (equalsResult) {\n      return Equal;\n    }\n\n    return purify.Left({ left, right, type: \"BooleanEquals\" });\n  }\n\n  export type Unequal =\n  | {\n    readonly left: {\n      readonly array: readonly any[];\n      readonly element: any;\n      readonly elementIndex: number;\n    };\n    readonly right: {\n      readonly array: readonly any[];\n      readonly unequals: readonly Unequal[];\n    };\n    readonly type: \"ArrayElement\";\n  }\n  | {\n    readonly left: readonly any[];\n    readonly right: readonly any[];\n    readonly type: \"ArrayLength\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"BooleanEquals\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"LeftError\";\n  }\n  | {\n    readonly right: any;\n    readonly type: \"LeftNull\";\n  }\n  | {\n    readonly left: bigint | boolean | number | string;\n    readonly right: bigint | boolean | number | string;\n    readonly type: \"Primitive\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly propertyName: string;\n    readonly propertyValuesUnequal: Unequal;\n    readonly type: \"Property\";\n  }\n  | {\n    readonly left: any;\n    readonly right: any;\n    readonly type: \"RightError\";\n  }\n  | {\n    readonly left: any;\n    readonly type: \"RightNull\";\n  };\n}    \n";
-    const maybeEquals = "export function $maybeEquals<T>(\n  leftMaybe: purify.Maybe<T>,\n  rightMaybe: purify.Maybe<T>,\n  valueEquals: (left: T, right: T) => boolean | $EqualsResult,\n): $EqualsResult {\n  if (leftMaybe.isJust()) {\n    if (rightMaybe.isJust()) {\n      return $EqualsResult.fromBooleanEqualsResult(\n        leftMaybe,\n        rightMaybe,\n        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),\n      );\n    }\n    return purify.Left({\n      left: leftMaybe.unsafeCoerce(),\n      type: \"RightNull\",\n    });\n  }\n\n  if (rightMaybe.isJust()) {\n    return purify.Left({\n      right: rightMaybe.unsafeCoerce(),\n      type: \"LeftNull\",\n    });\n  }\n\n  return $EqualsResult.Equal;\n}";
-    const LazyObjectSet = "/**\n * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyObjectSet<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>;\n  readonly stubs: readonly StubObjectT[];\n\n  constructor({ resolver, stubs }: {\n    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<purify.Either<Error, readonly ResolvedObjectT[]>>,\n    stubs: readonly StubObjectT[]\n  }) {\n    this.resolver = resolver;\n    this.stubs = stubs;\n  }\n\n  async resolve(options?: { limit?: number; offset?: number }): Promise<purify.Either<Error, readonly ResolvedObjectT[]>> {\n    if (this.stubs.length === 0) {\n      return purify.Either.of([]);\n    }\n\n    const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;\n    if (limit <= 0) {\n      return purify.Either.of([]);\n    }\n\n    let offset = options?.offset ?? 0;\n    if (offset < 0) {\n      offset = 0;\n    }\n\n    return await this.resolver(this.stubs.slice(offset, offset + limit).map(stub => stub.$identifier));\n  }\n}";
-    const LazyOptionalObject = "/**\n * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyOptionalObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: purify.Maybe<StubObjectT>;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: purify.Maybe<StubObjectT>\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  async resolve(): Promise<purify.Either<Error, purify.Maybe<ResolvedObjectT>>> {\n    if (this.stub.isNothing()) {\n      return purify.Either.of(purify.Maybe.empty());\n    }\n    return (await this.resolver(this.stub.unsafeCoerce().$identifier)).map(purify.Maybe.of);\n  }\n}";
-    const LazyRequiredObject = "/**\n * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.\n */\nexport class $LazyRequiredObject<ObjectIdentifierT extends rdfjs.BlankNode | rdfjs.NamedNode, ResolvedObjectT extends { $identifier: ObjectIdentifierT }, StubObjectT extends { $identifier: ObjectIdentifierT }> {\n  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>;\n  readonly stub: StubObjectT;\n\n  constructor({ resolver, stub }: {\n    resolver: (identifier: ObjectIdentifierT) => Promise<purify.Either<Error, ResolvedObjectT>>,\n    stub: StubObjectT\n  }) {\n    this.resolver = resolver;\n    this.stub = stub;\n  }\n\n  resolve(): Promise<purify.Either<Error, ResolvedObjectT>> {\n    return this.resolver(this.stub.$identifier);\n  }\n}";
-    const RdfVocabularies = "export namespace $RdfVocabularies {\n  export namespace rdf {\n    export const first = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#first\");\n    export const nil = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#nil\");\n    export const rest = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#rest\");\n    export const subject = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#subject\");\n    export const type = dataFactory.namedNode(\"http://www.w3.org/1999/02/22-rdf-syntax-ns#type\");\n  }\n\n  export namespace rdfs {\n    export const subClassOf = dataFactory.namedNode(\"http://www.w3.org/2000/01/rdf-schema#subClassOf\");\n  }\n\n  export namespace xsd {\n    export const boolean = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#boolean\");\n    export const date = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#date\");\n    export const dateTime = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#dateTime\");\n    export const integer = dataFactory.namedNode(\"http://www.w3.org/2001/XMLSchema#integer\");\n  }\n}";
-    const sparqlInstancesOfPattern = "/**\n * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .\n */\nexport function $sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: rdfjs.NamedNode | rdfjs.Variable, subject: sparqljs.Triple[\"subject\"] }): sparqljs.Pattern {\n  return {\n    triples: [\n      {\n        subject,\n        predicate: {\n          items: [\n            $RdfVocabularies.rdf.type,\n            {\n              items: [$RdfVocabularies.rdfs.subClassOf],\n              pathType: \"*\",\n              type: \"path\",\n            },\n          ],\n          pathType: \"/\",\n          type: \"path\",\n        },\n        object: rdfType,\n      },\n    ],\n    type: \"bgp\",\n  };\n}";
-    const strictEquals = "/**\n * Compare two values for strict equality (===), returning an $EqualsResult rather than a boolean.\n */\nexport function $strictEquals<T extends bigint | boolean | number | string>(\n  left: T,\n  right: T,\n): $EqualsResult {\n  return $EqualsResult.fromBooleanEqualsResult(left, right, left === right);\n}";
-    const UnwrapL = "type $UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
-    const UnwrapR = "type $UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
-}
-//# sourceMappingURL=SnippetDeclarations.d.ts.map