@rdfx/literal 0.0.1

package/dist/LiteralDecoder.d.ts

@@ -0,0 +1,20 @@
+import type { Literal } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import type { Primitive } from "./Primitive.js";
+/**
+ * Decode other types from RDF/JS Literals.
+ *
+ * Partially adapted from rdf-literal.js (https://github.com/rubensworks/rdf-literal.js), MIT license.
+ */
+export declare namespace LiteralDecoder {
+    function decodeBigIntLiteral(literal: Literal): Either<Error, bigint>;
+    function decodeBooleanLiteral(literal: Literal): Either<Error, boolean>;
+    function decodeDateLiteral(literal: Literal): Either<Error, Date>;
+    function decodeDateTimeLiteral(literal: Literal): Either<Error, Date>;
+    function decodeFloatLiteral(literal: Literal): Either<Error, number>;
+    function decodeIntLiteral(literal: Literal): Either<Error, number>;
+    function decodeNumberLiteral(literal: Literal): Either<Error, number>;
+    function decodePrimitiveLiteral(literal: Literal): Either<Error, Primitive>;
+    function decodeStringLiteral(literal: Literal): Either<Error, string>;
+}
+//# sourceMappingURL=LiteralDecoder.d.ts.map

package/dist/LiteralDecoder.js

@@ -0,0 +1,213 @@
+import { Either, Left } from "purify-ts";
+import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
+/**
+ * Decode other types from RDF/JS Literals.
+ *
+ * Partially adapted from rdf-literal.js (https://github.com/rubensworks/rdf-literal.js), MIT license.
+ */
+export var LiteralDecoder;
+(function (LiteralDecoder) {
+    const BIGINT_NUMBER_MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+    const BIGINT_NUMBER_MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+    function convertBigIntToNumber(literal, value) {
+        if (value >= BIGINT_NUMBER_MIN_SAFE_INTEGER &&
+            value <= BIGINT_NUMBER_MAX_SAFE_INTEGER) {
+            return Either.of(Number(value));
+        }
+        return Left(new LiteralValueError(literal, `bigint ${value} is outside number's safe integer range [${Number.MIN_SAFE_INTEGER}, ${Number.MAX_SAFE_INTEGER}]`));
+    }
+    function convertNumberToBigInt(literal, value) {
+        if (Number.isInteger(value)) {
+            return Either.of(BigInt(value));
+        }
+        return Left(new LiteralValueError(literal, `number ${value} is not an integer`));
+    }
+    function decodeBigIntLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteralValue(literal);
+            case "float":
+                return decodeFloatLiteralValue(literal).chain((value) => convertNumberToBigInt(literal, value));
+            case "int":
+                return decodeIntLiteralValue(literal).chain((value) => convertNumberToBigInt(literal, value));
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeBigIntLiteral = decodeBigIntLiteral;
+    function decodeBigIntLiteralValue(literal) {
+        return Either.encase(() => BigInt(literal.value));
+    }
+    function decodeBooleanLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "boolean") {
+            return decodeBooleanLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeBooleanLiteral = decodeBooleanLiteral;
+    function decodeBooleanLiteralValue(literal) {
+        switch (literal.value) {
+            case "false":
+            case "0":
+                return Either.of(false);
+            case "true":
+            case "1":
+                return Either.of(true);
+            default:
+                return Left(new LiteralValueError(literal));
+        }
+    }
+    function decodeDateLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "date") {
+            return decodeDateLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeDateLiteral = decodeDateLiteral;
+    function decodeDateLiteralValue(literal) {
+        if (!literal.value.match(/^[0-9]+-[0-9][0-9]-[0-9][0-9]Z?$/)) {
+            return Left(new LiteralValueError(literal));
+        }
+        return Either.of(new Date(literal.value));
+    }
+    function decodeDateTimeLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "datetime") {
+            return decodeDateTimeLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeDateTimeLiteral = decodeDateTimeLiteral;
+    function decodeDateTimeLiteralValue(literal) {
+        if (!literal.value.match(/^[0-9]+-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9](\.[0-9][0-9][0-9])?((Z?)|([+-][0-9][0-9]:[0-9][0-9]))$/)) {
+            return Left(new LiteralValueError(literal));
+        }
+        return Either.of(new Date(literal.value));
+    }
+    function decodeFloatLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+            case "int":
+                return decodeFloatLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeFloatLiteral = decodeFloatLiteral;
+    function decodeFloatLiteralValue(literal) {
+        return Either.encase(() => {
+            switch (literal.value.toUpperCase()) {
+                case "NAN":
+                    return NaN;
+                case "INF":
+                case "+INF":
+                    return Infinity;
+                case "-INF":
+                    return -Infinity;
+            }
+            const value = Number.parseFloat(literal.value);
+            if (Number.isNaN(value)) {
+                throw new LiteralValueError(literal, "not a number");
+            }
+            return value;
+        });
+    }
+    function decodeIntLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteral(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+            case "int":
+                return decodeIntLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeIntLiteral = decodeIntLiteral;
+    function decodeIntLiteralValue(literal) {
+        return decodeFloatLiteralValue(literal).chain((value) => {
+            if (Number.isInteger(value)) {
+                return Either.of(value);
+            }
+            return Left(new LiteralValueError(literal, `${value} is not an integer`));
+        });
+    }
+    function decodeNumberLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigint":
+                return decodeBigIntLiteralValue(literal).chain((value) => convertBigIntToNumber(literal, value));
+            case "float":
+                return decodeFloatLiteralValue(literal);
+            case "int":
+                return decodeIntLiteralValue(literal);
+            default:
+                return Left(new LiteralDatatypeError(literal));
+        }
+    }
+    LiteralDecoder.decodeNumberLiteral = decodeNumberLiteral;
+    function decodePrimitiveLiteral(literal) {
+        const literalDatatypeDefinition = literalDatatypeDefinitions[literal.datatype.value];
+        if (!literalDatatypeDefinition) {
+            return Left(new LiteralDatatypeError(literal));
+        }
+        switch (literalDatatypeDefinition.kind) {
+            case "bigdecimal":
+                return Left(new LiteralDatatypeError(literal, "unable to decode bigdecimal Literal"));
+            case "bigint":
+                return decodeBigIntLiteralValue(literal);
+            case "boolean":
+                return decodeBooleanLiteralValue(literal);
+            case "date":
+                return decodeDateLiteralValue(literal);
+            case "datetime":
+                return decodeDateTimeLiteralValue(literal);
+            case "float":
+                return decodeFloatLiteralValue(literal);
+            case "int":
+                return decodeIntLiteralValue(literal);
+            case "string":
+                return decodeStringLiteralValue(literal);
+        }
+    }
+    LiteralDecoder.decodePrimitiveLiteral = decodePrimitiveLiteral;
+    function decodeStringLiteral(literal) {
+        if (literalDatatypeDefinitions[literal.datatype.value]?.kind === "string") {
+            return decodeStringLiteralValue(literal);
+        }
+        return Left(new LiteralDatatypeError(literal));
+    }
+    LiteralDecoder.decodeStringLiteral = decodeStringLiteral;
+    function decodeStringLiteralValue(literal) {
+        return Either.of(literal.value);
+    }
+    class LiteralDatatypeError extends Error {
+        constructor(literal, message) {
+            super(message ?? `unrecognized Literal datatype: ${literal.datatype.value}`);
+            this.literal = literal;
+        }
+    }
+    class LiteralValueError extends Error {
+        constructor(literal, message) {
+            super(message);
+            this.literal = literal;
+        }
+    }
+})(LiteralDecoder || (LiteralDecoder = {}));
+//# sourceMappingURL=LiteralDecoder.js.map

package/dist/LiteralFactory.d.ts

@@ -0,0 +1,20 @@
+import type { DataFactory, Literal, NamedNode } from "@rdfjs/types";
+import type { Primitive } from "./Primitive.js";
+/**
+ * Factory with methods for creating RDF/JS Literals from other types.
+ */
+export declare class LiteralFactory {
+    private readonly dataFactory;
+    private readonly xsd;
+    constructor({ dataFactory }: {
+        dataFactory: DataFactory;
+    });
+    bigint(value: bigint, datatype?: NamedNode): Literal;
+    boolean(value: boolean, datatype?: NamedNode): Literal;
+    date(value: Date, datatype?: NamedNode): Literal;
+    number(value: number, datatype?: NamedNode): Literal;
+    private numeric;
+    primitive(value: Primitive, datatype?: NamedNode): Literal;
+    string(value: string, datatype?: NamedNode): Literal;
+}
+//# sourceMappingURL=LiteralFactory.d.ts.map

package/dist/LiteralFactory.js

@@ -0,0 +1,200 @@
+import { literalDatatypeDefinitions } from "./literalDatatypeDefinitions.js";
+class DatatypeRangeError extends RangeError {
+    constructor(datatype) {
+        super(`datatype out of range: ${datatype.value}`);
+        this.datatype = datatype;
+    }
+}
+/**
+ * Factory with methods for creating RDF/JS Literals from other types.
+ */
+export class LiteralFactory {
+    constructor({ dataFactory }) {
+        this.dataFactory = dataFactory;
+        this.xsd = {
+            boolean: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean"),
+            byte: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
+            date: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date"),
+            dateTime: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
+            dateTimeStamp: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTimeStamp"),
+            decimal: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
+            double: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double"),
+            float: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#float"),
+            int: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int"),
+            integer: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer"),
+            long: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#long"),
+            short: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#short"),
+            string: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string"),
+            unsignedByte: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte"),
+            unsignedInt: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt"),
+            unsignedLong: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong"),
+            unsignedShort: this.dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort"),
+        };
+    }
+    bigint(value, datatype) {
+        return this.numeric(value, datatype ?? this.xsd.integer);
+    }
+    boolean(value, datatype) {
+        if (!datatype) {
+            datatype = this.xsd.boolean;
+        }
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition && datatypeDefinition.kind !== "boolean") {
+            throw new DatatypeRangeError(datatype);
+        }
+        return this.dataFactory.literal(value.toString(), datatype);
+    }
+    date(value, datatype) {
+        if (!datatype) {
+            datatype = this.xsd.dateTime;
+        }
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition) {
+            switch (datatypeDefinition.kind) {
+                case "date":
+                    return this.dataFactory.literal(value.toISOString().replace(/T.*$/, ""), datatype);
+                case "datetime":
+                    return this.dataFactory.literal(value.toISOString(), datatype);
+                default:
+                    throw new DatatypeRangeError(datatype);
+            }
+        }
+        // case "http://www.w3.org/2001/XMLSchema#gDay":
+        //   return this.dataFactory.literal(
+        //     value.getUTCDate().toString(),
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gMonthDay":
+        //   return this.dataFactory.literal(
+        //     `${value.getUTCMonth() + 1}-${value.getUTCDate()}`,
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gYear":
+        //   return this.dataFactory.literal(
+        //     value.getUTCFullYear().toString(),
+        //     datatype,
+        //   );
+        // case "http://www.w3.org/2001/XMLSchema#gYearMonth":
+        //   return this.dataFactory.literal(
+        //     `${value.getUTCFullYear()}-${value.getUTCMonth() + 1}`,
+        //     datatype,
+        //   );
+        return this.dataFactory.literal(value.toISOString(), datatype);
+    }
+    number(value, datatype) {
+        if (!datatype) {
+            if (Number.isInteger(value)) {
+                if (value < 0) {
+                    datatype = [this.xsd.byte, this.xsd.short, this.xsd.int].find((checkDatatype) => {
+                        const checkDatatypeDefinition = literalDatatypeDefinitions[checkDatatype.value];
+                        if (checkDatatypeDefinition?.kind !== "int") {
+                            throw new Error("should never happen");
+                        }
+                        return value >= checkDatatypeDefinition.range[0];
+                    });
+                }
+                else {
+                    datatype = [
+                        this.xsd.unsignedByte,
+                        this.xsd.unsignedShort,
+                        this.xsd.unsignedInt,
+                    ].find((checkDatatype) => {
+                        const checkDatatypeDefinition = literalDatatypeDefinitions[checkDatatype.value];
+                        if (checkDatatypeDefinition?.kind !== "int") {
+                            throw new Error("should never happen");
+                        }
+                        return value <= checkDatatypeDefinition.range[1];
+                    });
+                }
+                if (!datatype) {
+                    datatype = this.xsd.integer;
+                }
+            }
+            else {
+                datatype = this.xsd.double;
+            }
+        }
+        return this.numeric(value, datatype);
+    }
+    numeric(value, datatype) {
+        let valueString;
+        const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+        if (datatypeDefinition) {
+            if (Number.isNaN(value) || value === Infinity || value === -Infinity) {
+                if (datatypeDefinition.kind !== "float") {
+                    throw new RangeError(`NaN/INF/-INF values only supported by xsd:double and xsd:float`);
+                }
+            }
+            else {
+                switch (datatypeDefinition.kind) {
+                    case "bigdecimal":
+                    case "bigint":
+                    case "float":
+                    case "int": {
+                        const [min, max] = datatypeDefinition.range;
+                        if ((min !== undefined && value < min) ||
+                            (max !== undefined && value > max)) {
+                            throw new RangeError(`value (${value}) outside range [${min}, ${max}] of ${datatype.value}`);
+                        }
+                        break;
+                    }
+                    default:
+                        throw new DatatypeRangeError(datatype);
+                }
+                if (datatypeDefinition.kind === "float") {
+                    // Convert the number to scientific notation so Turtle will recognize it as an double without ^^
+                    // Example: 1 -> 1e0
+                    // Assume this coercion to number won't lose anything since we checked the range above.
+                    let [mantissa, exponent] = Number(value).toExponential().split("e");
+                    exponent = exponent.replace(/^\+/, "").replace(/^(-?)0+(\d)/, "$1$2");
+                    valueString = `${mantissa}e${exponent}`;
+                }
+            }
+        }
+        if (!valueString) {
+            if (typeof value === "number") {
+                if (Number.isNaN(value)) {
+                    valueString = "NaN";
+                }
+                else if (value === Infinity) {
+                    valueString = "INF";
+                }
+                else if (value === -Infinity) {
+                    valueString = "-INF";
+                }
+            }
+            if (!valueString) {
+                valueString = value.toString(10);
+            }
+        }
+        return this.dataFactory.literal(valueString, datatype);
+    }
+    primitive(value, datatype) {
+        switch (typeof value) {
+            case "bigint":
+                return this.bigint(value, datatype);
+            case "boolean":
+                return this.boolean(value, datatype);
+            case "object": {
+                if (value instanceof Date) {
+                    return this.date(value, datatype);
+                }
+                throw new Error("not implemented");
+            }
+            case "number":
+                return this.number(value, datatype);
+            case "string":
+                return this.string(value, datatype);
+        }
+    }
+    string(value, datatype) {
+        if (datatype) {
+            const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+            if (datatypeDefinition && datatypeDefinition.kind !== "string") {
+                throw new DatatypeRangeError(datatype);
+            }
+        }
+        return this.dataFactory.literal(value, datatype);
+    }
+}
+//# sourceMappingURL=LiteralFactory.js.map

package/dist/Primitive.d.ts

@@ -0,0 +1,2 @@
+export type Primitive = bigint | boolean | Date | number | string;
+//# sourceMappingURL=Primitive.d.ts.map

package/dist/Primitive.js

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./LiteralDecoder.js";
+export * from "./LiteralFactory.js";
+export * from "./literalDatatypeDefinitions.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./LiteralDecoder.js";
+export * from "./LiteralFactory.js";
+export * from "./literalDatatypeDefinitions.js";
+//# sourceMappingURL=index.js.map

package/dist/literalDatatypeDefinitions.d.ts

@@ -0,0 +1,24 @@
+type LiteralDatatypeDefinition = {
+    kind: "bigdecimal";
+    readonly range: [undefined, undefined];
+} | {
+    kind: "bigint";
+    range: readonly [bigint | undefined, bigint | undefined];
+} | {
+    kind: "boolean";
+} | {
+    kind: "date";
+} | {
+    kind: "datetime";
+} | {
+    kind: "float";
+    readonly range: readonly [number, number];
+} | {
+    kind: "int";
+    readonly range: readonly [number, number];
+} | {
+    kind: "string";
+};
+export declare const literalDatatypeDefinitions: Record<string, LiteralDatatypeDefinition>;
+export {};
+//# sourceMappingURL=literalDatatypeDefinitions.d.ts.map

package/dist/literalDatatypeDefinitions.js

@@ -0,0 +1,116 @@
+export const literalDatatypeDefinitions = {
+    // Boolean
+    "http://www.w3.org/2001/XMLSchema#boolean": {
+        kind: "boolean",
+    },
+    // Date
+    "http://www.w3.org/2001/XMLSchema#date": {
+        kind: "date",
+    },
+    // Date-time
+    "http://www.w3.org/2001/XMLSchema#dateTime": {
+        kind: "datetime",
+    },
+    "http://www.w3.org/2001/XMLSchema#dateTimeStamp": {
+        kind: "datetime",
+    },
+    // Fixed-width floats
+    // 32-bit
+    "http://www.w3.org/2001/XMLSchema#float": {
+        kind: "float",
+        range: [-3.4028235e38, 3.4028235e38],
+    },
+    // 64-bit
+    "http://www.w3.org/2001/XMLSchema#double": {
+        kind: "float",
+        // Number.MIN_VALUE is the smallest positive number greater than 0
+        range: [-Number.MAX_VALUE, Number.MAX_VALUE],
+    },
+    // Arbitrary precision decimal
+    "http://www.w3.org/2001/XMLSchema#decimal": {
+        kind: "bigdecimal",
+        range: [undefined, undefined],
+    },
+    // Fixed-width integers
+    // 8-bit signed
+    "http://www.w3.org/2001/XMLSchema#byte": {
+        kind: "int",
+        range: [-128, 127],
+    },
+    // 16-bit signed
+    "http://www.w3.org/2001/XMLSchema#short": {
+        kind: "int",
+        range: [-32768, 32767],
+    },
+    // 32-bit signed
+    "http://www.w3.org/2001/XMLSchema#int": {
+        kind: "int",
+        range: [-2147483648, 2147483647],
+    },
+    // 64-bit signed
+    "http://www.w3.org/2001/XMLSchema#long": {
+        kind: "bigint",
+        range: [-9223372036854775808n, 9223372036854775807n],
+    },
+    // 8-bit unsigned
+    "http://www.w3.org/2001/XMLSchema#unsignedByte": {
+        kind: "int",
+        range: [0, 255],
+    },
+    // 16-bit unsigned
+    "http://www.w3.org/2001/XMLSchema#unsignedShort": {
+        kind: "int",
+        range: [0, 65535],
+    },
+    // 32-bit unsigned
+    "http://www.w3.org/2001/XMLSchema#unsignedInt": {
+        kind: "int",
+        range: [0, 4294967295],
+    },
+    // 64-bit unsigned
+    "http://www.w3.org/2001/XMLSchema#unsignedLong": {
+        kind: "bigint",
+        range: [0n, 18446744073709551615n],
+    },
+    // Arbitrary precision integers
+    "http://www.w3.org/2001/XMLSchema#integer": {
+        kind: "bigint",
+        range: [undefined, undefined],
+    },
+    "http://www.w3.org/2001/XMLSchema#negativeInteger": {
+        kind: "bigint",
+        range: [undefined, -1n],
+    },
+    "http://www.w3.org/2001/XMLSchema#nonNegativeInteger": {
+        kind: "bigint",
+        range: [0n, undefined],
+    },
+    "http://www.w3.org/2001/XMLSchema#nonPositiveInteger": {
+        kind: "bigint",
+        range: [undefined, 0n],
+    },
+    "http://www.w3.org/2001/XMLSchema#positiveInteger": {
+        kind: "bigint",
+        range: [1n, undefined],
+    },
+    // String
+    "http://www.w3.org/1999/02/22-rdf-syntax-ns#dirLangString": {
+        kind: "string",
+    },
+    "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#anyURI": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#base64Binary": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#duration": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#hexBinary": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#language": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#Name": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#NCName": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#NMTOKEN": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#NOTATION": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#normalizedString": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#QName": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#string": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#time": { kind: "string" },
+    "http://www.w3.org/2001/XMLSchema#token": { kind: "string" },
+};
+//# sourceMappingURL=literalDatatypeDefinitions.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "dependencies": {
+    "@rdfjs/types": "~2.0.1",
+    "purify-ts": "~2.1.4"
+  },
+  "devDependencies": {
+    "@rdfjs/data-model": "~2.1.1",
+    "@tpluscode/rdf-ns-builders": "~4.3.0",
+    "@types/rdfjs__data-model": "~2.0.9"
+  },
+  "files": [
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/literal",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run --project @rdfx/literal"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.1"
+}