@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/JsonLd-DobFrQNa.d.mts

@@ -0,0 +1,242 @@
+import { _ as Quad } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { c as Parser, i as Format, l as RdfParseError, m as Serializer, o as ParseOptions$1, p as SerializeOptions$1, r as Codec, s as ParseResult, u as RdfSerializeError } from "./Serialization-Df8iVauT.mjs";
+import { n as JsonLdError } from "./JsonLdError-DSOfHkOy.mjs";
+import { o as Loader, s as RemoteDocument } from "./DocumentLoader-ZUCEVrW5.mjs";
+import "effect/MutableHashMap";
+import "effect/Option";
+import * as Effect from "effect/Effect";
+import "effect/Order";
+/** @internal */
+type ProcessingMode = 'json-ld-1.0' | 'json-ld-1.1';
+declare namespace JsonLd_d_exports {
+  export { FrameOptions, FromRdfOptions, Input, JsonArray, JsonObjectValue, JsonValue, Options, ParseOptions, SerializeOptions, ToRdfOptions, codec, compact, expand, flatten, format, frame, fromRdf, parse, parser, serialize, serializer, toQuads, toRdf };
+}
+/**
+ * Any JSON value.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type JsonValue = null | boolean | number | string | JsonArray | JsonObjectValue;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface JsonArray extends ReadonlyArray<JsonValue> {}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface JsonObjectValue {
+  readonly [key: string]: JsonValue;
+}
+/**
+ * The input of the JSON-LD algorithms: a JSON document (object or array), the
+ * URL of a document to load, or an already loaded `RemoteDocument`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Input = JsonValue | RemoteDocument | object;
+/**
+ * Options shared by all JSON-LD algorithms (the `JsonLdOptions` of the
+ * JSON-LD API).
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface Options {
+  /** The base IRI. Defaults to the URL of the input document, if any. */
+  readonly base?: string | null | undefined;
+  /** `json-ld-1.1` (default) or `json-ld-1.0`. */
+  readonly processingMode?: ProcessingMode | undefined;
+  /** A context to apply before expanding the input. */
+  readonly expandContext?: unknown;
+  /** Process map entries in lexicographical order. Defaults to `false`. */
+  readonly ordered?: boolean | undefined;
+  /** Replace single-element arrays by their element. Defaults to `true`. */
+  readonly compactArrays?: boolean | undefined;
+  /** Make IRIs relative to the base IRI when compacting. Defaults to `true`. */
+  readonly compactToRelative?: boolean | undefined;
+  /** Extract all JSON-LD script elements from HTML input. */
+  readonly extractAllScripts?: boolean | undefined;
+  /**
+   * A document loader to use instead of the `DocumentLoader` service from
+   * the environment.
+   */
+  readonly documentLoader?: Loader | undefined;
+}
+/**
+ * Options for `toRdf`.
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface ToRdfOptions extends Options {
+  /**
+   * How to represent `@direction`: as `i18n-datatype` literals, as
+   * `compound-literal` blank nodes, or not at all (default).
+   */
+  readonly rdfDirection?: 'i18n-datatype' | 'compound-literal' | null | undefined;
+  /**
+   * Generalized RDF (blank node predicates) cannot be represented by the
+   * core term model; such triples are always dropped.
+   */
+  readonly produceGeneralizedRdf?: boolean | undefined;
+}
+/**
+ * Options for `fromRdf`.
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface FromRdfOptions {
+  readonly processingMode?: ProcessingMode | undefined;
+  readonly ordered?: boolean | undefined;
+  /** Convert `xsd:boolean`, `xsd:integer` and `xsd:double` to native JSON values. */
+  readonly useNativeTypes?: boolean | undefined;
+  /** Keep `rdf:type` as a regular property instead of `@type`. */
+  readonly useRdfType?: boolean | undefined;
+  readonly rdfDirection?: 'i18n-datatype' | 'compound-literal' | null | undefined;
+}
+/**
+ * Options for `frame`.
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface FrameOptions extends Options {
+  /** The default `@embed` flag: `@once` (default), `@always`, `@never` or `@link`. */
+  readonly embed?: '@once' | '@always' | '@never' | '@link' | undefined;
+  /** The default `@explicit` flag. */
+  readonly explicit?: boolean | undefined;
+  /** The default `@omitDefault` flag. */
+  readonly omitDefault?: boolean | undefined;
+  /** The default `@requireAll` flag. */
+  readonly requireAll?: boolean | undefined;
+  /** Omit `@graph` when the result is a single node. Defaults to `false` in 1.1. */
+  readonly omitGraph?: boolean | undefined;
+}
+/**
+ * Expands a JSON-LD document (JSON-LD 1.1 API, Expansion Algorithm).
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const expand: (input: Input, options?: Options) => Effect.Effect<Array<JsonObjectValue>, JsonLdError>;
+/**
+ * Compacts a JSON-LD document against a context (JSON-LD 1.1 API,
+ * Compaction Algorithm). The context may be a context definition, an array
+ * of contexts, an IRI, or a document with an `@context` entry.
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const compact: (input: Input, context: unknown, options?: Options) => Effect.Effect<JsonObjectValue, JsonLdError>;
+/**
+ * Flattens a JSON-LD document (JSON-LD 1.1 API, Flattening Algorithm),
+ * optionally compacting the result.
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const flatten: (input: Input, context?: unknown, options?: Options) => Effect.Effect<JsonValue, JsonLdError>;
+/**
+ * Frames a JSON-LD document (JSON-LD 1.1 Framing).
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const frame: (input: Input, frameInput: unknown, options?: FrameOptions) => Effect.Effect<JsonObjectValue, JsonLdError>;
+/**
+ * Converts a JSON-LD document to an RDF dataset (Deserialize JSON-LD to RDF
+ * Algorithm).
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const toRdf: (input: Input, options?: ToRdfOptions) => Effect.Effect<Dataset, JsonLdError>;
+/**
+ * Like `toRdf`, but returns the quads in document order.
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const toQuads: (input: Input, options?: ToRdfOptions) => Effect.Effect<ReadonlyArray<Quad>, JsonLdError>;
+/**
+ * Converts RDF quads to expanded JSON-LD (Serialize RDF as JSON-LD
+ * Algorithm).
+ *
+ * @since 0.1.0
+ * @category algorithms
+ */
+declare const fromRdf: (quads: Iterable<Quad>, options?: FromRdfOptions) => Effect.Effect<Array<JsonObjectValue>, JsonLdError>;
+/**
+ * The JSON-LD format.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const format: Format;
+/**
+ * Options for parsing JSON-LD documents to RDF.
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface ParseOptions extends ParseOptions$1, ToRdfOptions {}
+/**
+ * Options for serialising RDF as JSON-LD.
+ *
+ * @since 0.1.0
+ * @category options
+ */
+interface SerializeOptions extends SerializeOptions$1, FromRdfOptions {
+  /** A context to compact the output with. */
+  readonly context?: unknown;
+  /** Replace single-element arrays by their element. Defaults to `true`. */
+  readonly compactArrays?: boolean | undefined;
+  /** JSON indentation. Defaults to 2; use 0 for compact output. */
+  readonly indent?: number | undefined;
+  readonly documentLoader?: Loader | undefined;
+}
+/**
+ * Parses a JSON-LD document into RDF.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<ParseResult, RdfParseError>;
+/**
+ * Serialises quads as a JSON-LD document. Without a context (and without
+ * prefixes) the output is expanded JSON-LD; otherwise it is compacted with
+ * the given context, extended with one term per prefix.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serialize: (quads: Iterable<Quad>, options?: SerializeOptions) => Effect.Effect<string, RdfSerializeError>;
+/**
+ * The JSON-LD parser.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parser: Parser<ParseOptions>;
+/**
+ * The JSON-LD serializer.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializer: Serializer<SerializeOptions>;
+/**
+ * The JSON-LD codec.
+ *
+ * @since 0.1.0
+ * @category codecs
+ */
+declare const codec: Codec<ParseOptions, SerializeOptions>;
+export { toQuads as C, serializer as S, frame as _, JsonLd_d_exports as a, parser as b, Options as c, ToRdfOptions as d, codec as f, format as g, flatten as h, JsonArray as i, ParseOptions as l, expand as m, FromRdfOptions as n, JsonObjectValue as o, compact as p, Input as r, JsonValue as s, FrameOptions as t, SerializeOptions as u, fromRdf as v, toRdf as w, serialize as x, parse as y };
+//# sourceMappingURL=JsonLd-DobFrQNa.d.mts.map

package/dist/JsonLdError-C9J-BxfG.mjs

@@ -0,0 +1,106 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Schema from "effect/Schema";
+// src/jsonld/JsonLdError.ts
+/**
+* The error raised by every JSON-LD algorithm. It carries one of the error
+* codes defined by the JSON-LD 1.1 Processing Algorithms and API
+* specification (and the JSON-LD 1.1 Framing specification).
+*
+* @since 0.1.0
+*/
+var JsonLdError_exports = /* @__PURE__ */ __exportAll({
+	JsonLdError: () => JsonLdError,
+	codes: () => codes,
+	isJsonLdError: () => isJsonLdError,
+	make: () => make
+});
+/**
+* The JSON-LD error codes.
+*
+* @since 0.1.0
+* @category models
+*/
+const codes = [
+	"colliding keywords",
+	"conflicting indexes",
+	"context overflow",
+	"cyclic IRI mapping",
+	"invalid @id value",
+	"invalid @import value",
+	"invalid @included value",
+	"invalid @index value",
+	"invalid @nest value",
+	"invalid @prefix value",
+	"invalid @propagate value",
+	"invalid @protected value",
+	"invalid @reverse value",
+	"invalid @version value",
+	"invalid base direction",
+	"invalid base IRI",
+	"invalid container mapping",
+	"invalid context entry",
+	"invalid context nullification",
+	"invalid default language",
+	"invalid IRI mapping",
+	"invalid JSON literal",
+	"invalid keyword alias",
+	"invalid language map value",
+	"invalid language mapping",
+	"invalid language-tagged string",
+	"invalid language-tagged value",
+	"invalid local context",
+	"invalid remote context",
+	"invalid reverse property",
+	"invalid reverse property map",
+	"invalid reverse property value",
+	"invalid scoped context",
+	"invalid script element",
+	"invalid set or list object",
+	"invalid term definition",
+	"invalid type mapping",
+	"invalid type value",
+	"invalid typed value",
+	"invalid value object",
+	"invalid value object value",
+	"invalid vocab mapping",
+	"IRI confused with prefix",
+	"keyword redefinition",
+	"loading document failed",
+	"loading remote context failed",
+	"multiple context link headers",
+	"processing mode conflict",
+	"protected term redefinition",
+	"list of lists",
+	"compaction to list of lists",
+	"recursive context inclusion",
+	"invalid frame",
+	"invalid @embed value"
+];
+/**
+* A JSON-LD processing error.
+*
+* @since 0.1.0
+* @category errors
+*/
+var JsonLdError = class extends Schema.TaggedError()("JsonLdError", {
+	code: Schema.Literals(codes),
+	message: Schema.String
+}) {};
+/**
+* Creates a `JsonLdError`. The message defaults to the code.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (code, message) => new JsonLdError({
+	code,
+	message: message === void 0 ? code : `${code}: ${message}`
+});
+/**
+* @since 0.1.0
+* @category guards
+*/
+const isJsonLdError = (u) => u instanceof JsonLdError;
+export { make as a, isJsonLdError as i, JsonLdError_exports as n, codes as r, JsonLdError as t };
+
+//# sourceMappingURL=JsonLdError-C9J-BxfG.mjs.map

package/dist/JsonLdError-C9J-BxfG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonLdError-C9J-BxfG.mjs","names":[],"sources":["../src/jsonld/JsonLdError.ts"],"sourcesContent":["/**\n * The error raised by every JSON-LD algorithm. It carries one of the error\n * codes defined by the JSON-LD 1.1 Processing Algorithms and API\n * specification (and the JSON-LD 1.1 Framing specification).\n *\n * @since 0.1.0\n */\nimport * as Schema from 'effect/Schema';\n\n/**\n * The JSON-LD error codes.\n *\n * @since 0.1.0\n * @category models\n */\nexport const codes = [\n  'colliding keywords',\n  'conflicting indexes',\n  'context overflow',\n  'cyclic IRI mapping',\n  'invalid @id value',\n  'invalid @import value',\n  'invalid @included value',\n  'invalid @index value',\n  'invalid @nest value',\n  'invalid @prefix value',\n  'invalid @propagate value',\n  'invalid @protected value',\n  'invalid @reverse value',\n  'invalid @version value',\n  'invalid base direction',\n  'invalid base IRI',\n  'invalid container mapping',\n  'invalid context entry',\n  'invalid context nullification',\n  'invalid default language',\n  'invalid IRI mapping',\n  'invalid JSON literal',\n  'invalid keyword alias',\n  'invalid language map value',\n  'invalid language mapping',\n  'invalid language-tagged string',\n  'invalid language-tagged value',\n  'invalid local context',\n  'invalid remote context',\n  'invalid reverse property',\n  'invalid reverse property map',\n  'invalid reverse property value',\n  'invalid scoped context',\n  'invalid script element',\n  'invalid set or list object',\n  'invalid term definition',\n  'invalid type mapping',\n  'invalid type value',\n  'invalid typed value',\n  'invalid value object',\n  'invalid value object value',\n  'invalid vocab mapping',\n  'IRI confused with prefix',\n  'keyword redefinition',\n  'loading document failed',\n  'loading remote context failed',\n  'multiple context link headers',\n  'processing mode conflict',\n  'protected term redefinition',\n  'list of lists',\n  'compaction to list of lists',\n  'recursive context inclusion',\n  'invalid frame',\n  'invalid @embed value',\n] as const;\n\n/**\n * A JSON-LD error code, e.g. `\"invalid @id value\"`.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Code = (typeof codes)[number];\n\n/**\n * A JSON-LD processing error.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class JsonLdError extends Schema.TaggedError<JsonLdError>()('JsonLdError', {\n  code: Schema.Literals(codes),\n  message: Schema.String,\n}) {}\n\n/**\n * Creates a `JsonLdError`. The message defaults to the code.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (code: Code, message?: string): JsonLdError =>\n  new JsonLdError({ code, message: message === undefined ? code : `${code}: ${message}` });\n\n/**\n * @since 0.1.0\n * @category guards\n */\nexport const isJsonLdError = (u: unknown): u is JsonLdError => u instanceof JsonLdError;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,QAAQ;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;AAgBA,IAAa,cAAb,cAAiC,OAAO,YAAyB,CAAC,CAAC,eAAe;CAChF,MAAM,OAAO,SAAS,KAAK;CAC3B,SAAS,OAAO;AAClB,CAAC,CAAC,CAAC,CAAC;;;;;;;AAQJ,MAAa,QAAQ,MAAY,YAC/B,IAAI,YAAY;CAAE;CAAM,SAAS,YAAY,KAAA,IAAY,OAAO,GAAG,KAAK,IAAI;AAAU,CAAC;;;;;AAMzF,MAAa,iBAAiB,MAAiC,aAAa"}

package/dist/JsonLdError-DSOfHkOy.d.mts

@@ -0,0 +1,43 @@
+import * as Schema from "effect/Schema";
+declare namespace JsonLdError_d_exports {
+  export { Code, JsonLdError, codes, isJsonLdError, make };
+}
+/**
+ * The JSON-LD error codes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+declare const codes: readonly ["colliding keywords", "conflicting indexes", "context overflow", "cyclic IRI mapping", "invalid @id value", "invalid @import value", "invalid @included value", "invalid @index value", "invalid @nest value", "invalid @prefix value", "invalid @propagate value", "invalid @protected value", "invalid @reverse value", "invalid @version value", "invalid base direction", "invalid base IRI", "invalid container mapping", "invalid context entry", "invalid context nullification", "invalid default language", "invalid IRI mapping", "invalid JSON literal", "invalid keyword alias", "invalid language map value", "invalid language mapping", "invalid language-tagged string", "invalid language-tagged value", "invalid local context", "invalid remote context", "invalid reverse property", "invalid reverse property map", "invalid reverse property value", "invalid scoped context", "invalid script element", "invalid set or list object", "invalid term definition", "invalid type mapping", "invalid type value", "invalid typed value", "invalid value object", "invalid value object value", "invalid vocab mapping", "IRI confused with prefix", "keyword redefinition", "loading document failed", "loading remote context failed", "multiple context link headers", "processing mode conflict", "protected term redefinition", "list of lists", "compaction to list of lists", "recursive context inclusion", "invalid frame", "invalid @embed value"];
+/**
+ * A JSON-LD error code, e.g. `"invalid @id value"`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Code = (typeof codes)[number];
+declare const JsonLdError_base: Schema.Class<JsonLdError, Schema.TaggedStruct<"JsonLdError", {
+  readonly code: Schema.Literals<readonly ["colliding keywords", "conflicting indexes", "context overflow", "cyclic IRI mapping", "invalid @id value", "invalid @import value", "invalid @included value", "invalid @index value", "invalid @nest value", "invalid @prefix value", "invalid @propagate value", "invalid @protected value", "invalid @reverse value", "invalid @version value", "invalid base direction", "invalid base IRI", "invalid container mapping", "invalid context entry", "invalid context nullification", "invalid default language", "invalid IRI mapping", "invalid JSON literal", "invalid keyword alias", "invalid language map value", "invalid language mapping", "invalid language-tagged string", "invalid language-tagged value", "invalid local context", "invalid remote context", "invalid reverse property", "invalid reverse property map", "invalid reverse property value", "invalid scoped context", "invalid script element", "invalid set or list object", "invalid term definition", "invalid type mapping", "invalid type value", "invalid typed value", "invalid value object", "invalid value object value", "invalid vocab mapping", "IRI confused with prefix", "keyword redefinition", "loading document failed", "loading remote context failed", "multiple context link headers", "processing mode conflict", "protected term redefinition", "list of lists", "compaction to list of lists", "recursive context inclusion", "invalid frame", "invalid @embed value"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A JSON-LD processing error.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class JsonLdError extends JsonLdError_base {}
+/**
+ * Creates a `JsonLdError`. The message defaults to the code.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (code: Code, message?: string) => JsonLdError;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isJsonLdError: (u: unknown) => u is JsonLdError;
+export { isJsonLdError as a, codes as i, JsonLdError as n, make as o, JsonLdError_d_exports as r, Code as t };
+//# sourceMappingURL=JsonLdError-DSOfHkOy.d.mts.map

package/dist/LanguageTag-BCu8rcmX.d.mts

@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+declare namespace LanguageTag_d_exports {
+  export { LanguageTagSchema, isWellFormed, normalize };
+}
+/**
+ * Whether a string is a well-formed BCP 47 language tag (§2.2.9): it matches
+ * the `Language-Tag` ABNF, case-insensitively. Registry validity (known
+ * subtags, no duplicate variants or extensions) is not checked.
+ *
+ * @since 0.1.0
+ * @category predicates
+ */
+declare const isWellFormed: (tag: string) => boolean;
+/**
+ * The form a language tag takes in an RDF term: lower case (RDF 1.2 compares
+ * tags case-insensitively, and `Term.literal` lower-cases them).
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const normalize: (tag: string) => string;
+/**
+ * Schema of a well-formed BCP 47 language tag (`isWellFormed`): a string,
+ * decoded unchanged.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const LanguageTagSchema: Schema.String;
+/**
+ * The type `LanguageTagSchema` decodes to: a string.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type LanguageTagSchema = typeof LanguageTagSchema.Type;
+export { normalize as i, LanguageTag_d_exports as n, isWellFormed as r, LanguageTagSchema as t };
+//# sourceMappingURL=LanguageTag-BCu8rcmX.d.mts.map

package/dist/LanguageTag-BcOpMGZ4.mjs

@@ -0,0 +1,89 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import * as Schema from "effect/Schema";
+// src/LanguageTag.ts
+/**
+* BCP 47 language tags, as RDF 1.2 requires them: well-formedness (BCP 47
+* §2.2.9, the `Language-Tag` ABNF of §2.1), the canonical lower-case form
+* RDF terms carry, and a `Schema` for validating tags at a boundary.
+*
+* The syntax packages keep their grammar's own `LANGTAG` production
+* (`[a-zA-Z]+ ('-' [a-zA-Z0-9]+)*`), which the W3C suites test and which is
+* looser than BCP 47; use `isWellFormed` where full BCP 47 is wanted.
+*
+* @since 0.1.0
+*/
+var LanguageTag_exports = /* @__PURE__ */ __exportAll({
+	LanguageTagSchema: () => LanguageTagSchema,
+	isWellFormed: () => isWellFormed,
+	normalize: () => normalize
+});
+const ALNUM = "[a-z0-9]";
+const LANGUAGE = "(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4,8})";
+const SCRIPT = "(?:-[a-z]{4})?";
+const REGION = "(?:-(?:[a-z]{2}|[0-9]{3}))?";
+const VARIANTS = `(?:-(?:${ALNUM}{5,8}|[0-9]${ALNUM}{3}))*`;
+const EXTENSIONS = `(?:-[0-9a-wy-z](?:-${ALNUM}{2,8})+)*`;
+const PRIVATE_USE = `x(?:-${ALNUM}{1,8})+`;
+const LANGTAG = `${LANGUAGE}${SCRIPT}${REGION}${VARIANTS}${EXTENSIONS}(?:-${PRIVATE_USE})?`;
+const GRANDFATHERED = [
+	"en-gb-oed",
+	"i-ami",
+	"i-bnn",
+	"i-default",
+	"i-enochian",
+	"i-hak",
+	"i-klingon",
+	"i-lux",
+	"i-mingo",
+	"i-navajo",
+	"i-pwn",
+	"i-tao",
+	"i-tay",
+	"i-tsu",
+	"sgn-be-fr",
+	"sgn-be-nl",
+	"sgn-ch-de",
+	"art-lojban",
+	"cel-gaulish",
+	"no-bok",
+	"no-nyn",
+	"zh-guoyu",
+	"zh-hakka",
+	"zh-min",
+	"zh-min-nan",
+	"zh-xiang"
+].join("|");
+const WELL_FORMED = new RegExp(`^(?:${LANGTAG}|${PRIVATE_USE}|${GRANDFATHERED})$`, "i");
+/**
+* Whether a string is a well-formed BCP 47 language tag (§2.2.9): it matches
+* the `Language-Tag` ABNF, case-insensitively. Registry validity (known
+* subtags, no duplicate variants or extensions) is not checked.
+*
+* @since 0.1.0
+* @category predicates
+*/
+const isWellFormed = (tag) => WELL_FORMED.test(tag);
+/**
+* The form a language tag takes in an RDF term: lower case (RDF 1.2 compares
+* tags case-insensitively, and `Term.literal` lower-cases them).
+*
+* @since 0.1.0
+* @category formatting
+*/
+const normalize = (tag) => tag.toLowerCase();
+/**
+* Schema of a well-formed BCP 47 language tag (`isWellFormed`): a string,
+* decoded unchanged.
+*
+* @since 0.1.0
+* @category schemas
+*/
+const LanguageTagSchema = Schema.String.check(Schema.makeFilter((tag) => isWellFormed(tag), {
+	identifier: "isLanguageTag",
+	title: "Language tag",
+	description: "A well-formed BCP 47 language tag.",
+	expected: "a BCP 47 language tag"
+})).annotate({ identifier: "LanguageTag" });
+export { normalize as i, LanguageTag_exports as n, isWellFormed as r, LanguageTagSchema as t };
+
+//# sourceMappingURL=LanguageTag-BcOpMGZ4.mjs.map

package/dist/LanguageTag-BcOpMGZ4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageTag-BcOpMGZ4.mjs","names":[],"sources":["../src/LanguageTag.ts"],"sourcesContent":["/**\n * BCP 47 language tags, as RDF 1.2 requires them: well-formedness (BCP 47\n * §2.2.9, the `Language-Tag` ABNF of §2.1), the canonical lower-case form\n * RDF terms carry, and a `Schema` for validating tags at a boundary.\n *\n * The syntax packages keep their grammar's own `LANGTAG` production\n * (`[a-zA-Z]+ ('-' [a-zA-Z0-9]+)*`), which the W3C suites test and which is\n * looser than BCP 47; use `isWellFormed` where full BCP 47 is wanted.\n *\n * @since 0.1.0\n */\nimport * as Schema from 'effect/Schema';\n\nconst ALNUM = '[a-z0-9]';\n// language = 2*3ALPHA [\"-\" extlang] / 4ALPHA / 5*8ALPHA; extlang = 3ALPHA *2(\"-\" 3ALPHA)\nconst LANGUAGE = '(?:[a-z]{2,3}(?:-[a-z]{3}){0,3}|[a-z]{4,8})';\nconst SCRIPT = '(?:-[a-z]{4})?';\nconst REGION = '(?:-(?:[a-z]{2}|[0-9]{3}))?';\nconst VARIANTS = `(?:-(?:${ALNUM}{5,8}|[0-9]${ALNUM}{3}))*`;\n// singleton = alphanum except \"x\"\nconst EXTENSIONS = `(?:-[0-9a-wy-z](?:-${ALNUM}{2,8})+)*`;\nconst PRIVATE_USE = `x(?:-${ALNUM}{1,8})+`;\nconst LANGTAG = `${LANGUAGE}${SCRIPT}${REGION}${VARIANTS}${EXTENSIONS}(?:-${PRIVATE_USE})?`;\n\n// The grandfathered tags (BCP 47 §2.1, `irregular` and `regular`).\nconst GRANDFATHERED = [\n  'en-gb-oed',\n  'i-ami',\n  'i-bnn',\n  'i-default',\n  'i-enochian',\n  'i-hak',\n  'i-klingon',\n  'i-lux',\n  'i-mingo',\n  'i-navajo',\n  'i-pwn',\n  'i-tao',\n  'i-tay',\n  'i-tsu',\n  'sgn-be-fr',\n  'sgn-be-nl',\n  'sgn-ch-de',\n  'art-lojban',\n  'cel-gaulish',\n  'no-bok',\n  'no-nyn',\n  'zh-guoyu',\n  'zh-hakka',\n  'zh-min',\n  'zh-min-nan',\n  'zh-xiang',\n].join('|');\n\nconst WELL_FORMED = new RegExp(`^(?:${LANGTAG}|${PRIVATE_USE}|${GRANDFATHERED})$`, 'i');\n\n/**\n * Whether a string is a well-formed BCP 47 language tag (§2.2.9): it matches\n * the `Language-Tag` ABNF, case-insensitively. Registry validity (known\n * subtags, no duplicate variants or extensions) is not checked.\n *\n * @since 0.1.0\n * @category predicates\n */\nexport const isWellFormed = (tag: string): boolean => WELL_FORMED.test(tag);\n\n/**\n * The form a language tag takes in an RDF term: lower case (RDF 1.2 compares\n * tags case-insensitively, and `Term.literal` lower-cases them).\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const normalize = (tag: string): string => tag.toLowerCase();\n\n/**\n * Schema of a well-formed BCP 47 language tag (`isWellFormed`): a string,\n * decoded unchanged.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const LanguageTagSchema: Schema.String = Schema.String.check(\n  Schema.makeFilter((tag: string) => isWellFormed(tag), {\n    identifier: 'isLanguageTag',\n    title: 'Language tag',\n    description: 'A well-formed BCP 47 language tag.',\n    expected: 'a BCP 47 language tag',\n  }),\n).annotate({ identifier: 'LanguageTag' });\n\n/**\n * The type `LanguageTagSchema` decodes to: a string.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type LanguageTagSchema = typeof LanguageTagSchema.Type;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAaA,MAAM,QAAQ;AAEd,MAAM,WAAW;AACjB,MAAM,SAAS;AACf,MAAM,SAAS;AACf,MAAM,WAAW,UAAU,MAAM,aAAa,MAAM;AAEpD,MAAM,aAAa,sBAAsB,MAAM;AAC/C,MAAM,cAAc,QAAQ,MAAM;AAClC,MAAM,UAAU,GAAG,WAAW,SAAS,SAAS,WAAW,WAAW,MAAM,YAAY;AAGxF,MAAM,gBAAgB;CACpB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC,CAAC,KAAK,GAAG;AAEV,MAAM,cAAc,IAAI,OAAO,OAAO,QAAQ,GAAG,YAAY,GAAG,cAAc,KAAK,GAAG;;;;;;;;;AAUtF,MAAa,gBAAgB,QAAyB,YAAY,KAAK,GAAG;;;;;;;;AAS1E,MAAa,aAAa,QAAwB,IAAI,YAAY;;;;;;;;AASlE,MAAa,oBAAmC,OAAO,OAAO,MAC5D,OAAO,YAAY,QAAgB,aAAa,GAAG,GAAG;CACpD,YAAY;CACZ,OAAO;CACP,aAAa;CACb,UAAU;AACZ,CAAC,CACH,CAAC,CAAC,SAAS,EAAE,YAAY,cAAc,CAAC"}

package/dist/LanguageTag.d.mts

@@ -0,0 +1,2 @@
+import { i as normalize, r as isWellFormed, t as LanguageTagSchema } from "./LanguageTag-BCu8rcmX.mjs";
+export { LanguageTagSchema, isWellFormed, normalize };

package/dist/LanguageTag.mjs

@@ -0,0 +1 @@
+export { t as LanguageTagSchema, r as isWellFormed, i as normalize } from "./LanguageTag-BcOpMGZ4.mjs";