@kulupu-linku/sona 0.3.5 → 2.0.2

package/dist/server/versioning.js

@@ -0,0 +1,8 @@
+import "../utils-QiKwNnnL.js";
+import "../v1-DkHVwPCI.js";
+import "../utils-DkAaVBMs.js";
+import "../utils-Z1o5sWsW.js";
+import "../v2-CDtbJFxV.js";
+import { a as fetchFile, i as apps, o as versions } from "../v1-obRCoWWK.js";
+
+export { apps, fetchFile, versions };

package/dist/utils-DkAaVBMs.js

@@ -0,0 +1,33 @@
+import { z } from "zod/v4";
+import { zValidator } from "@hono/zod-validator";
+
+//#region src/server/utils.ts
+const entries = (o) => {
+	return Object.entries(o);
+};
+const keys = (o) => {
+	return Object.keys(o);
+};
+const filterObject = (o, predicate) => {
+	return Object.fromEntries(entries(o).filter(([key, value]) => predicate([key, value])));
+};
+const langIdCoalesce = (lang, langs) => {
+	if (lang in langs) return lang;
+	for (const [id, metadata] of Object.entries(langs)) {
+		if (lang === metadata.locale) return id;
+		for (const [key, name] of Object.entries(metadata.name)) if (lang.toLowerCase() === name?.toLowerCase()) return id;
+	}
+};
+const langValidator = zValidator("query", z.object({ lang: z.string().regex(/^([^,]+,)*[^,]+/).optional() }));
+function joinPath(...segments) {
+	return segments.filter(Boolean).join("/").replace(/\/{2,}/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function mergeToKey(target, tkey, ...sources) {
+	if (!sources.length) return target;
+	const source = sources.shift();
+	for (const key in source) target[key][tkey] = source[key];
+	return target;
+}
+
+//#endregion
+export { langIdCoalesce as a, keys as i, filterObject as n, langValidator as o, joinPath as r, mergeToKey as s, entries as t };

package/dist/utils-QiKwNnnL.js

@@ -0,0 +1,37 @@
+import { z } from "zod/v4";
+
+//#region src/lib/v1/utils.ts
+const Book = z.union([
+	z.literal("pu"),
+	z.literal("ku suli"),
+	z.literal("ku lili"),
+	z.literal("none")
+]);
+const CoinedEra = z.union([
+	z.literal("pre-pu"),
+	z.literal("post-pu"),
+	z.literal("post-ku")
+]);
+const UsageCategory = z.union([
+	z.literal("core"),
+	z.literal("common"),
+	z.literal("uncommon"),
+	z.literal("obscure"),
+	z.literal("sandbox")
+]);
+const WritingSystem = z.enum([
+	"sitelen pona",
+	"sitelen sitelen",
+	"alphabet",
+	"syllabary",
+	"logography",
+	"tokiponido alphabet",
+	"tokiponido syllabary",
+	"tokiponido logography"
+]);
+function getTranslatedData(data, key, language) {
+	return (data.translations[language] ?? data.translations["en"])[key];
+}
+
+//#endregion
+export { getTranslatedData as a, WritingSystem as i, CoinedEra as n, UsageCategory as r, Book as t };

package/dist/utils-Z1o5sWsW.js

@@ -0,0 +1,40 @@
+import { z } from "zod/v4";
+
+//#region src/lib/v2/utils.ts
+const Date = z.string().regex(/^(?<year>20\d{2})(?:-(?<month>0[1-9]|1[0-2])(?:-(?<day>0[1-9]|[12]\d|3[01]))?)?$/);
+const OptionalDate = z.string().regex(/^(?:|(?<year>20\d{2})(?:-(?<month>0[1-9]|1[0-2])(?:-(?<day>0[1-9]|[12]\d|3[01]))?)?|(?<startYear>20\d{2})-(?<endYear>20\d{2}))$/);
+const Score = z.number().min(0).max(100);
+const Book = z.enum([
+	"pu",
+	"ku suli",
+	"ku lili",
+	"none"
+]);
+const Era = z.enum([
+	"pre-pu",
+	"post-pu",
+	"post-ku"
+]);
+const UsageCategory = z.enum([
+	"core",
+	"common",
+	"uncommon",
+	"obscure",
+	"sandbox"
+]);
+const WritingSystem = z.enum([
+	"sitelen pona",
+	"sitelen sitelen",
+	"alphabet",
+	"syllabary",
+	"logography",
+	"tokiponido alphabet",
+	"tokiponido syllabary",
+	"tokiponido logography"
+]);
+function getTranslatedData(data, key, language) {
+	return (data.translations[language] ?? data.translations["en"])[key];
+}
+
+//#endregion
+export { Score as a, getTranslatedData as c, OptionalDate as i, Date as n, UsageCategory as o, Era as r, WritingSystem as s, Book as t };

package/dist/v1-DkHVwPCI.js

@@ -0,0 +1,139 @@
+import { i as WritingSystem, n as CoinedEra, r as UsageCategory, t as Book } from "./utils-QiKwNnnL.js";
+import { z } from "zod/v4";
+
+//#region src/lib/v1/index.ts
+const YearMonth = z.string().regex(/^20\d{2}-(0[1-9]|1[0-2])$/g);
+const Word = z.object({
+	id: z.string().min(1).describe(`A unique identifier for the word. Usually the word but may have an integer added in case of a word with multiple definitions (like "we")`),
+	author_verbatim: z.string().describe("The author's original definition, taken verbatim in their words"),
+	author_verbatim_source: z.string().describe("Where the author's original definition is located (usually Discord)"),
+	book: Book.describe("Which official Toki Pona book was this word featured in, if any."),
+	coined_era: CoinedEra.or(z.literal("")).describe("When this word was coined (relative to the publication dates of the official Toki Pona books, if known)"),
+	coined_year: z.string().describe("The year when this word was coined (if known)"),
+	creator: z.array(z.string()).describe("The person who created this word (if known)"),
+	ku_data: z.record(z.string().min(1).describe("A translation of the word into English proposed in ku"), z.number().min(0).max(100).describe("The percentage of ku survey respondents who report this translation as accurate to their usage.")).optional().describe("The usage data of the word as described in ku (the official Toki Pona dictionary)"),
+	see_also: z.array(z.string()).describe("A list of related words"),
+	resources: z.object({
+		sona_pona: z.string().url().optional().describe("A link to the word's page on sona.pona.la, a Toki Pona wiki. May redirect for words with references but no dedicated page."),
+		lipamanka_semantic: z.string().url().optional().describe("A link to lipamanka's description of the word's semantic space.")
+	}).optional().describe("Non-Linku resources related to the specific word, such as wiki links."),
+	representations: z.object({
+		sitelen_emosi: z.string().emoji().optional().describe("The sitelen emosi representation of this word, a script for writing Toki Pona using emoji"),
+		sitelen_jelo: z.array(z.string().emoji()).min(1).optional().describe("One or more example emojis for how the word can be written in sitelen jelo"),
+		ligatures: z.array(z.string().min(1)).optional().describe("A list of sitelen Lasina representations of the word, used by ligature fonts to visually convert latin characters into sitelen pona"),
+		sitelen_sitelen: z.string().url().optional().describe("A URL pointing to an image of this word's sitelen sitelen hieroglyphic block"),
+		ucsur: z.string().regex(/^U\+[\da-fA-F]{4,6}$/g).optional().describe("The word's UCSUR codepoint, as defined in https://www.kreativekorp.com/ucsur/charts/sitelen.html")
+	}).optional().describe("Ways of representing this word in the real world, via text/computers"),
+	source_language: z.string().describe("The language this word originated from"),
+	usage_category: UsageCategory.describe("The word's usage category, according to a survey performed by the Linku Project"),
+	word: z.string().describe(`The word's actual text, in case of a word with multiple definitions (like "we")`),
+	deprecated: z.boolean().describe("Whether or not the word is considered deprecated by its author."),
+	etymology: z.array(z.object({
+		word: z.string().optional().describe("One of the root words of this word, as written out in its language of origin"),
+		alt: z.string().optional().describe(`A latinized representation of the "word" field`)
+	})).describe("Unlocalized etymological values regarding this word's origin"),
+	audio: z.array(z.object({
+		author: z.string().describe("The author of the audio file in `link`."),
+		link: z.string().url().describe("A link to the audio file for the word, pronounced by `author`.")
+	}).describe("Audio files of the words pronounced out loud")),
+	pu_verbatim: z.object({
+		en: z.string().describe("The original definition in the English version of pu"),
+		fr: z.string().describe("The original definition in the French version of pu"),
+		de: z.string().describe("The original definition in the German version of pu"),
+		eo: z.string().describe("The original definition in the Esperanto version of pu")
+	}).optional().describe("The original definition of the word in pu, the first official Toki Pona book"),
+	usage: z.record(z.string().regex(/^20\d{2}-(0[1-9]|1[0-2])$/g), z.number().min(0).max(100)).describe("The percentage of people in the Toki Pona community who use this word, according to surveys performed by the Linku Project")
+}).describe("General info on a Toki Pona word");
+const CommentaryTranslation = z.record(z.string().min(1), z.string()).describe("Localized commentary regarding Toki Pona words");
+const DefinitionTranslation = z.record(z.string().min(1), z.string().min(1)).describe("Localized definitions of Toki Pona words");
+const SitelenPonaTranslation = z.record(z.string().min(1), z.string()).describe("Localized descriptions of the origins of the sitelen pona glyphs for Toki Pona words");
+const EtymologyTranslation = z.record(z.string().min(1), z.array(z.object({
+	definition: z.string().optional().describe("The localized definition of the root word in its origin language"),
+	language: z.string().describe("The localized name of the language this word originated from")
+}))).describe("Localized etymological values for Toki Pona words");
+const Sign = z.object({
+	definition: z.string().describe("The definition of the sign as a single toki pona word."),
+	id: z.string().describe("A globally unique name for the sign which is also a gloss."),
+	is_two_handed: z.boolean().describe("Whether the sign is two-handed or not."),
+	new_gloss: z.string().describe("The more recent, preferred gloss for this sign."),
+	old_gloss: z.string().describe("The older gloss for this sign, similar to `id`."),
+	etymology: z.array(z.object({
+		language: z.string().describe("The language of the sign."),
+		sign: z.string().optional().describe("The name of the sign such that it could be found in a sign language dictionary.")
+	})).describe("Unlocalized etymological values regarding this sign's origin"),
+	signwriting: z.object({
+		fsw: z.string().describe("The [Formal SignWriting](https://en.wikipedia.org/wiki/SignWriting) representation of the sign."),
+		swu: z.string().describe("The [SignWriting with Unicode](https://en.wikipedia.org/wiki/SignWriting) representation of the sign.")
+	}).describe("Scripts for representing a sign as characters."),
+	video: z.object({
+		gif: z.string().optional().describe("A link to a gif of the sign being signed."),
+		mp4: z.string().optional().describe("a link to an mp4 of the sign being signed.")
+	}).describe("Videos of the sign being performed, by format.")
+}).describe("Unlocalized info on a Luka Pona sign");
+const FingerspellingSign = z.object({
+	id: z.string().describe("A globally unique name for the sign which is also a gloss."),
+	is_two_handed: z.boolean().describe("Whether the sign is two-handed or not."),
+	etymology: z.array(z.object({
+		language: z.string().describe("The language of the sign."),
+		sign: z.string().describe("The name of the sign such that it could be found in a sign language dictionary.")
+	})).describe("Unlocalized etymological values regarding this sign's origin"),
+	signwriting: z.object({
+		fsw: z.string().describe("The Formal Sign Writing representation of the sign."),
+		swu: z.string().describe("The Sign Writing with Unicode representation of hte sign.")
+	}).describe("Scripts for representing a sign as characters."),
+	video: z.object({
+		gif: z.string().optional().describe("A link to a gif of the sign being signed."),
+		mp4: z.string().optional().describe("a link to an mp4 of the sign being signed.")
+	}).describe("Videos of the sign being performed, by format.")
+}).describe("Unlocalized info on a fingerspelling sign.");
+const ParametersTranslation = z.record(z.string().min(1), z.object({
+	handshape: z.string().optional().describe("The shape of the hand when signing, identified by its name in ASL. Should not be translated in any language other than Toki Pona"),
+	movement: z.string().optional().describe("The motion of the hand when signing."),
+	placement: z.string().optional().describe("The placement of the hand when signing."),
+	orientation: z.string().optional().describe("The orientation of the hand when signing.")
+})).describe("Partly localized descriptions of how a sign is signed.");
+const IconTranslation = z.record(z.string().min(1), z.string()).describe("Localized descriptions of the thing a sign represents.");
+const Font = z.object({
+	id: z.string().min(1).describe("The font's unique ID, identifying it among other fonts"),
+	creator: z.array(z.string()).describe("a list of this font's creators"),
+	features: z.array(z.string()).describe("a list of features this font supports"),
+	filename: z.string().regex(/^(?:.+\.(ttf|otf|woff2|woff))?$/).describe("the name of the file this font is stored in at https://github.com/lipu-linku/ijo"),
+	last_updated: YearMonth.optional().describe("the rough date of this font's last update"),
+	license: z.string().describe("an SPDX expression describing this font's license: https://spdx.org/licenses/"),
+	ligatures: z.boolean().describe("whether this font supports ligatures"),
+	name: z.string().min(1).describe("this font's name"),
+	style: z.string().min(1).describe("the general style of this font"),
+	ucsur: z.boolean().describe("whether this font conforms to the UCSUR standard: https://www.kreativekorp.com/ucsur/charts/sitelen.html"),
+	version: z.string().describe("the current version of this font"),
+	writing_system: WritingSystem.describe("the writing system this font uses as its script"),
+	links: z.object({
+		fontfile: z.string().url().optional().describe("a link to the font file published by the original author (not the mirror on the Linku Project's GitHub)"),
+		repo: z.string().url().optional().describe("a link to a web hosted repository of this font's source files (usually hosted on GitHub or GitLab)"),
+		webpage: z.string().url().optional().describe("a link to this font's home page, usually showcasing its features and usage/installation")
+	})
+}).describe("Info on a font for Toki Pona");
+const Words = z.record(z.string().min(1), Word.extend({ translations: z.record(z.string(), z.object({
+	commentary: CommentaryTranslation.valueType,
+	definition: DefinitionTranslation.valueType,
+	etymology: EtymologyTranslation.valueType,
+	sp_etymology: SitelenPonaTranslation.valueType
+})) })).describe("A raw data object containing dictionary info about Toki Pona words");
+const Signs = z.record(z.string().min(1), Sign.extend({ translations: z.record(z.string(), z.object({
+	parameters: ParametersTranslation.valueType,
+	icons: IconTranslation.valueType
+})) })).describe("A raw data object containing information about Luka Pona signs");
+const Fingerspelling = z.record(z.string().min(1), FingerspellingSign.extend({ translations: z.record(z.string(), z.object({ parameters: ParametersTranslation.valueType })) })).describe("A raw data object containing information about Luka Pona fingerspelling signs");
+const Fonts = z.record(z.string(), Font).describe("A raw data object containing all the fonts data in sona");
+const Languages = z.record(z.string().min(2).describe("The language code used by Crowdin. Approximates 2 letter code -> 3 letter code."), z.object({
+	id: z.string().min(2).describe("The language code used by Crowdin. Approximates 2 letter code -> 3 letter code."),
+	locale: z.string().describe("The locale code corresponding to the language."),
+	direction: z.union([z.literal("ltr"), z.literal("rtl")]).describe("The direction of the language's script."),
+	name: z.object({
+		en: z.string().describe("The name of the language in English."),
+		tok: z.string().optional().describe("The name of the language in Toki Pona."),
+		endonym: z.string().optional().describe("The name of the language in that language.")
+	})
+}).describe("The languages offered by sona Linku."));
+
+//#endregion
+export { FingerspellingSign as a, IconTranslation as c, Sign as d, Signs as f, Words as h, Fingerspelling as i, Languages as l, Word as m, DefinitionTranslation as n, Font as o, SitelenPonaTranslation as p, EtymologyTranslation as r, Fonts as s, CommentaryTranslation as t, ParametersTranslation as u };

package/dist/v1-obRCoWWK.js

@@ -0,0 +1,267 @@
+import { f as Signs, h as Words, i as Fingerspelling, l as Languages, s as Fonts } from "./v1-DkHVwPCI.js";
+import { a as langIdCoalesce, i as keys, n as filterObject, o as langValidator, r as joinPath, s as mergeToKey } from "./utils-DkAaVBMs.js";
+import { c as Languages$1, f as Words$1, i as Fonts$1, n as Fingerspellings, o as Glyphs, u as Signs$1 } from "./v2-CDtbJFxV.js";
+import { Hono } from "hono";
+import { z } from "zod/v4";
+import { zValidator } from "@hono/zod-validator";
+import { HTTPException } from "hono/http-exception";
+import PLazy from "p-lazy";
+
+//#region src/server/v2/index.ts
+const API_VERSION$1 = "v2";
+const config$1 = {
+	words: {
+		root: "/",
+		filename: "words.json",
+		schema: Words$1,
+		translations: true
+	},
+	glyphs: {
+		root: "/",
+		filename: "glyphs.json",
+		schema: Glyphs,
+		translations: true
+	},
+	sandbox_words: {
+		root: "sandbox/",
+		filename: "words.json",
+		schema: Words$1,
+		translations: true
+	},
+	sandbox_glyphs: {
+		root: "sandbox/",
+		filename: "glyphs.json",
+		schema: Glyphs,
+		translations: true
+	},
+	signs: {
+		root: "luka_pona/",
+		filename: "signs.json",
+		schema: Signs$1,
+		translations: true
+	},
+	fingerspellings: {
+		root: "luka_pona/",
+		filename: "fingerspellings.json",
+		schema: Fingerspellings,
+		translations: true
+	},
+	fonts: {
+		root: "/",
+		filename: "fonts.json",
+		schema: Fonts$1,
+		translations: false
+	},
+	languages: {
+		root: "/",
+		filename: "languages.json",
+		schema: Languages$1,
+		translations: false
+	}
+};
+let CACHE = {};
+const fetchData = async (key, langcode = "en") => {
+	if (CACHE && CACHE[key] && CACHE[key][langcode]) return CACHE[key][langcode];
+	const file = await fetchFile(API_VERSION$1, config$1[key], langcode);
+	if (!file.success) throw new HTTPException(500, { message: z.prettifyError(file.error) });
+	CACHE[key] ??= {};
+	CACHE[key][langcode] = file.data;
+	return file.data;
+};
+const langParamtoLangcode = async (langParam) => {
+	if (!langParam) return "en";
+	return langIdCoalesce(langParam, await fetchData("languages"));
+};
+const datasetEndpoint = (key) => {
+	return async (c) => {
+		const data = await fetchData(key, await langParamtoLangcode(c.req.query("lang")));
+		return c.json(data, 200);
+	};
+};
+const singleItemEndpoint = (key, param, descriptor) => {
+	return async (c) => {
+		const data = await fetchData(key, await langParamtoLangcode(c.req.query("lang")));
+		const id = c.req.param(param);
+		const itemData = data[id];
+		return itemData ? c.json({
+			success: true,
+			data: itemData
+		}, 200) : c.json({
+			success: false,
+			message: `Could not find the ${descriptor} ${id}`
+		}, 400);
+	};
+};
+const app$1 = new Hono().get("/", (c) => c.redirect("/v2/words")).get("/words", langValidator, datasetEndpoint("words")).get("/words/:word", langValidator, zValidator("param", z.object({ word: z.string() })), singleItemEndpoint("words", "word", "word")).get("/glyphs", langValidator, datasetEndpoint("glyphs")).get("/glyphs/:glyph", langValidator, zValidator("param", z.object({ glyph: z.string() })), singleItemEndpoint("glyphs", "glyph", "glyph")).get("/sandbox", (c) => c.redirect("/v2/sandbox/words")).get("/sandbox/words", langValidator, datasetEndpoint("sandbox_words")).get("/sandbox/words/:word", langValidator, zValidator("param", z.object({ word: z.string() })), singleItemEndpoint("sandbox_words", "word", "sandbox word")).get("/sandbox/glyphs", langValidator, datasetEndpoint("sandbox_glyphs")).get("/sandbox/glyphs/:glyph", langValidator, zValidator("param", z.object({ glyph: z.string() })), singleItemEndpoint("sandbox_glyphs", "glyph", "sandbox glyph")).get("/luka_pona/signs", langValidator, datasetEndpoint("signs")).get("/luka_pona/signs/:sign", langValidator, zValidator("param", z.object({ sign: z.string() })), singleItemEndpoint("signs", "sign", "sign")).get("/luka_pona/fingerspellings", langValidator, datasetEndpoint("fingerspellings")).get("/luka_pona/fingerspellings/:fingerspelling", langValidator, zValidator("param", z.object({ sign: z.string() })), singleItemEndpoint("fingerspellings", "fingerspelling", "fingerspelling")).get("/fonts", datasetEndpoint("fonts")).get("/fonts/:font", zValidator("param", z.object({ font: z.string() })), singleItemEndpoint("fonts", "font", "font")).get("/languages", datasetEndpoint("languages")).get("/languages/:language", zValidator("param", z.object({ language: z.string() })), singleItemEndpoint("languages", "language", "language"));
+var v2_default = app$1;
+
+//#endregion
+//#region src/server/versioning.ts
+const IMPORT_ROOT = "/src/raw/";
+const DATA = import.meta.glob("@raw/**/*.json", {
+	import: "default",
+	eager: true
+});
+const versions = {
+	v1: config,
+	v2: config$1
+};
+const apps = {
+	v1: v1_default,
+	v2: v2_default
+};
+const assertImport = async (imports, file, path) => {
+	if (!file) throw new Error(`Missing file: ${path}. Available: [${Object.keys(imports).slice(0, 10)}]`);
+	if (typeof file !== "object") console.error(`Unexpected file type for ${path}:`, typeof file, file);
+};
+const fetchFile = async (version, config$2, langcode = "en") => {
+	const { root = "/", filename, schema, translations = false } = config$2;
+	let path = "/" + joinPath(IMPORT_ROOT, version, root, filename);
+	let file = DATA[path];
+	await assertImport(DATA, file, path);
+	if (version === "v2" && translations === true) {
+		let translationPath = "/" + joinPath(IMPORT_ROOT, version, root, "translations", langcode, filename);
+		let translationFile = DATA[translationPath];
+		await assertImport(DATA, translationFile, translationPath);
+		file = mergeToKey(file, "translations", translationFile);
+	}
+	const parsed = await schema.safeParseAsync(file);
+	if (!parsed.success) throw new Error(`Invalid input in ${filename}: ${parsed.error.message}`);
+	return parsed;
+};
+
+//#endregion
+//#region src/server/v1/index.ts
+const API_VERSION = "v1";
+const config = {
+	words: {
+		filename: "words.json",
+		schema: Words
+	},
+	sandbox: {
+		filename: "sandbox.json",
+		schema: Words
+	},
+	fingerspellings: {
+		filename: "fingerspelling.json",
+		schema: Fingerspelling
+	},
+	signs: {
+		filename: "signs.json",
+		schema: Signs
+	},
+	fonts: {
+		filename: "fonts.json",
+		schema: Fonts
+	},
+	languages: {
+		filename: "languages.json",
+		schema: Languages
+	}
+};
+const rawData = PLazy.from(async () => {
+	const res = {};
+	for (const key of keys(config)) {
+		const file = await fetchFile(API_VERSION, config[key]);
+		if (!file.success) throw new HTTPException(500, { message: z.prettifyError(file.error) });
+		res[key] = file.data;
+	}
+	return res;
+});
+const languagesFilter = (nested) => async (c, next) => {
+	await next();
+	const body = await c.res.clone().json();
+	if ("ok" in body && body.ok === false) return body;
+	const requestedLanguages = c.req.query("lang")?.split(",") ?? ["en"];
+	if (requestedLanguages.length === 1 && requestedLanguages[0] === "*") return;
+	const languages = (await rawData).languages;
+	const mappedLangs = requestedLanguages.map((lang) => langIdCoalesce(lang, languages));
+	if (mappedLangs.includes(void 0)) throw new HTTPException(400, { message: `Cannot find one or more of the requested languages: ${requestedLanguages.join(", ")}` });
+	if (nested) c.res = new Response(JSON.stringify(Object.fromEntries(Object.entries(body).filter((e) => typeof e[1] === "object" && !!e[1] && "translations" in e[1] && typeof e[1]["translations"] === "object").map(([k, v]) => {
+		return [k, {
+			...v,
+			translations: filterObject(v["translations"], ([k$1]) => mappedLangs.includes(k$1))
+		}];
+	}))), c.res);
+	else c.res = new Response(JSON.stringify({
+		...body.data,
+		translations: filterObject(body.data["translations"], ([k]) => mappedLangs.includes(k.toString()))
+	}), c.res);
+};
+const app = new Hono().get("/", (c) => c.redirect("/v1/words")).get("/words", langValidator, languagesFilter(true), async (c) => {
+	const data = (await rawData).words;
+	return c.json(data, 200);
+}).get("/words/:word", langValidator, zValidator("param", z.object({ word: z.string() })), languagesFilter(false), async (c) => {
+	const word = (await rawData).words[c.req.param("word")];
+	return word ? c.json({
+		ok: true,
+		data: word
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find the word ${c.req.param("word")}`
+	}, 400);
+}).get("/sandbox", langValidator, languagesFilter(true), async (c) => {
+	const data = (await rawData).sandbox;
+	return c.json(data, 200);
+}).get("/sandbox/:word", langValidator, zValidator("param", z.object({ word: z.string() })), languagesFilter(false), async (c) => {
+	const word = (await rawData).sandbox[c.req.param("word")];
+	return word ? c.json({
+		ok: true,
+		data: word
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find the sandbox word "${c.req.param("word")}"`
+	}, 400);
+}).get("/luka_pona", (c) => {
+	return c.redirect("/v1/luka_pona/signs");
+}).get("/luka_pona/fingerspelling", langValidator, languagesFilter(true), async (c) => {
+	return c.json((await rawData).fingerspellings, 200);
+}).get("/luka_pona/fingerspelling/:sign", langValidator, zValidator("param", z.object({ sign: z.string() })), languagesFilter(true), async (c) => {
+	const sign = (await rawData).fingerspellings[c.req.param("sign")];
+	return sign ? c.json({
+		ok: true,
+		data: sign
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find a sign named ${sign}`
+	}, 400);
+}).get("/luka_pona/signs", langValidator, languagesFilter(true), async (c) => {
+	return c.json((await rawData).signs, 200);
+}).get("/luka_pona/signs/:sign", langValidator, zValidator("param", z.object({ sign: z.string() })), languagesFilter(true), async (c) => {
+	const sign = (await rawData).signs[c.req.param("sign")];
+	return sign ? c.json({
+		ok: true,
+		data: sign
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find a sign named ${sign}`
+	}, 400);
+}).get("/fonts", async (c) => {
+	return c.json((await rawData).fonts, 200);
+}).get("/fonts/:font", zValidator("param", z.object({ font: z.string() })), async (c) => {
+	const font = (await rawData).fonts[c.req.param("font")];
+	return font ? c.json({
+		ok: true,
+		data: font
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find a font named ${font}`
+	}, 400);
+}).get("/languages", async (c) => {
+	return c.json((await rawData).languages, 200);
+}).get("/languages/:language", zValidator("param", z.object({ language: z.string() })), async (c) => {
+	const language = c.req.param("language");
+	const languages = (await rawData).languages;
+	const langId = langIdCoalesce(language, languages);
+	return langId ? c.json({
+		ok: true,
+		data: languages[langId]
+	}, 200) : c.json({
+		ok: false,
+		message: `Could not find a language named ${language}`
+	}, 400);
+});
+var v1_default = app;
+
+//#endregion
+export { fetchFile as a, fetchData as c, apps as i, v2_default as l, languagesFilter as n, versions as o, v1_default as r, config$1 as s, config as t };