@nulib/clover 0.0.0-stage → 4.0.0-beta.0

package/dist/core/search.mjs

@@ -0,0 +1,154 @@
+"use client";
+import { parseAnnotationTarget } from "./annotations.mjs";
+import { fetchJson } from "./request.mjs";
+import { SEARCH_SET_ID } from "./search-service.mjs";
+import { asArray } from "../lib/asArray.mjs";
+const MAX_PAGES = 10;
+async function searchInto(store, service, query, request, signal) {
+  var _a, _b;
+  const manifestId = (_a = store.get().manifest) == null ? void 0 : _a.id;
+  try {
+    const { hits, set } = await search(service, query, { request, signal });
+    if (signal.aborted || ((_b = store.get().manifest) == null ? void 0 : _b.id) !== manifestId) return;
+    store.set({ search: { query, status: "ready", hits, set } });
+  } catch {
+    if (signal.aborted) return;
+    store.set({ search: { query, status: "error", hits: [], set: null } });
+  }
+}
+async function search(service, query, { request, signal } = {}) {
+  const url = new URL(service.id);
+  url.searchParams.set("q", query);
+  const pages = [];
+  let next = url.toString();
+  const seen = /* @__PURE__ */ new Set();
+  while (next && pages.length < MAX_PAGES && !seen.has(next)) {
+    seen.add(next);
+    const page = await fetchJson(request, next, signal);
+    pages.push(page);
+    next = nextPage(page);
+  }
+  return readResults(pages, query);
+}
+function targetV1(on) {
+  var _a;
+  const value = asArray(on)[0];
+  if (typeof value === "string" || !value) return value;
+  const full = value.full ?? value["@id"];
+  const fragment = (_a = asArray(value.selector)[0]) == null ? void 0 : _a.value;
+  return typeof fragment === "string" && typeof full === "string" ? `${full}#${fragment}` : full;
+}
+function nextPage(page) {
+  var _a;
+  const next = page.next ?? ((_a = page.within) == null ? void 0 : _a.next);
+  const id = typeof next === "string" ? next : (next == null ? void 0 : next.id) ?? (next == null ? void 0 : next["@id"]);
+  return typeof id === "string" ? id : null;
+}
+function readResults(pages, query) {
+  var _a, _b;
+  const entries = [];
+  const hits = [];
+  for (const page of pages) {
+    const v1 = Array.isArray(page.resources);
+    const annotations = v1 ? page.resources : asArray(page.items);
+    const byId = /* @__PURE__ */ new Map();
+    for (const annotation of annotations) {
+      const id = annotation.id ?? annotation["@id"];
+      const raw = v1 ? targetV1(annotation.on) : asArray(annotation.target)[0];
+      const target = parseAnnotationTarget(raw);
+      if (!id || !target.id) continue;
+      const text = v1 ? (_a = annotation.resource) == null ? void 0 : _a.chars : asArray(annotation.body).map((body) => body == null ? void 0 : body.value).find((value) => typeof value === "string");
+      const entry = {
+        id,
+        setId: SEARCH_SET_ID,
+        canvasId: target.id,
+        target,
+        motivation: ["highlighting"],
+        bodies: [{ value: String(text ?? query) }],
+        // One shape for the Canvas whichever version answered: a highlighting annotation.
+        annotation: {
+          id,
+          type: "Annotation",
+          motivation: ["highlighting"],
+          body: { type: "TextualBody", value: String(text ?? query) },
+          target: raw
+        }
+      };
+      byId.set(id, entry);
+      entries.push(entry);
+    }
+    const grouped = v1 ? readHitsV1(page, byId) : readHitsV2(page, byId);
+    const listed = new Set(grouped.flatMap((hit) => hit.entryIds));
+    hits.push(...grouped);
+    for (const entry of byId.values()) {
+      if (listed.has(entry.id)) continue;
+      hits.push({
+        id: entry.id,
+        canvasId: entry.canvasId,
+        entryIds: [entry.id],
+        match: ((_b = entry.bodies[0]) == null ? void 0 : _b.value) ?? query
+      });
+    }
+  }
+  return {
+    query,
+    hits,
+    set: {
+      id: SEARCH_SET_ID,
+      label: { none: [query] },
+      source: "search",
+      entries
+    }
+  };
+}
+function readHitsV1(page, byId) {
+  var _a;
+  const hits = [];
+  for (const hit of asArray(page.hits)) {
+    const entryIds = asArray(hit.annotations).filter(
+      (id) => byId.has(id)
+    );
+    if (!entryIds.length) continue;
+    hits.push({
+      id: entryIds.join(" "),
+      canvasId: byId.get(entryIds[0]).canvasId,
+      entryIds,
+      before: hit.before,
+      match: String(hit.match ?? ((_a = byId.get(entryIds[0]).bodies[0]) == null ? void 0 : _a.value) ?? ""),
+      after: hit.after
+    });
+  }
+  return hits;
+}
+function readHitsV2(page, byId) {
+  var _a, _b;
+  const hits = [];
+  for (const group of asArray(page.annotations)) {
+    for (const annotation of asArray(group == null ? void 0 : group.items)) {
+      const motivation = asArray(annotation == null ? void 0 : annotation.motivation);
+      if (!motivation.includes("contextualizing")) continue;
+      for (const target of asArray(annotation.target)) {
+        const source = typeof (target == null ? void 0 : target.source) === "string" ? target.source : (_a = target == null ? void 0 : target.source) == null ? void 0 : _a.id;
+        const entry = source ? byId.get(source) : void 0;
+        if (!entry) continue;
+        const quote = asArray(target.selector).find(
+          (selector) => (selector == null ? void 0 : selector.type) === "TextQuoteSelector"
+        );
+        hits.push({
+          id: `${annotation.id ?? source}#${source}`,
+          canvasId: entry.canvasId,
+          entryIds: [entry.id],
+          before: quote == null ? void 0 : quote.prefix,
+          match: String((quote == null ? void 0 : quote.exact) ?? ((_b = entry.bodies[0]) == null ? void 0 : _b.value) ?? ""),
+          after: quote == null ? void 0 : quote.suffix
+        });
+      }
+    }
+  }
+  return hits;
+}
+export {
+  readResults,
+  search,
+  searchInto
+};

package/dist/core/selectors.mjs

@@ -0,0 +1,94 @@
+"use client";
+import { resolveDirection, groupViews, resolveBehavior, viewOf } from "./sequence.mjs";
+import { parseAnnotationTarget } from "./annotations.mjs";
+const sequences = /* @__PURE__ */ new WeakMap();
+const EMPTY = { canvases: [], views: [], direction: "left-to-right" };
+function selectSequence(manifest) {
+  if (!manifest) return EMPTY;
+  let sequence = sequences.get(manifest);
+  if (!sequence) {
+    const canvases = (manifest.items ?? []).filter(
+      // `Body` draws each with its own part: `Canvas`, `Timeline` or `Scene`.
+      (item) => (item == null ? void 0 : item.type) === "Canvas" || (item == null ? void 0 : item.type) === "Timeline" || (item == null ? void 0 : item.type) === "Scene"
+    );
+    sequence = {
+      canvases,
+      views: groupViews(
+        canvases,
+        resolveBehavior(manifest.behavior)
+      ),
+      direction: resolveDirection(
+        manifest.viewingDirection
+      )
+    };
+    sequences.set(manifest, sequence);
+  }
+  return sequence;
+}
+const byId = /* @__PURE__ */ new WeakMap();
+function selectCanvas(manifest, id) {
+  if (!id) return null;
+  const sequence = selectSequence(manifest);
+  let canvases = byId.get(sequence);
+  if (!canvases) {
+    canvases = /* @__PURE__ */ new Map();
+    for (const canvas of sequence.canvases)
+      if (!canvases.has(canvas.id)) canvases.set(canvas.id, canvas);
+    byId.set(sequence, canvases);
+  }
+  return canvases.get(id) ?? null;
+}
+function selectPosition(manifest, canvasId) {
+  const { canvases, views } = selectSequence(manifest);
+  const index = canvases.findIndex((canvas) => canvas.id === canvasId);
+  return index === -1 ? 0 : viewOf(views, index);
+}
+const visible = /* @__PURE__ */ new WeakMap();
+const NONE = [];
+function selectVisibleCanvases(manifest, canvasId) {
+  if (!manifest) return NONE;
+  const position = selectPosition(manifest, canvasId);
+  let byView = visible.get(manifest);
+  if (!byView) visible.set(manifest, byView = /* @__PURE__ */ new Map());
+  let canvases = byView.get(position);
+  if (!canvases) {
+    const sequence = selectSequence(manifest);
+    canvases = (sequence.views[position] ?? []).map(
+      (index) => sequence.canvases[index]
+    );
+    byView.set(position, canvases);
+  }
+  return canvases;
+}
+function canvasOfView(manifest, view) {
+  var _a, _b;
+  const { canvases, views } = selectSequence(manifest);
+  const index = (_a = views[view]) == null ? void 0 : _a[0];
+  return index === void 0 ? null : ((_b = canvases[index]) == null ? void 0 : _b.id) ?? null;
+}
+function selectStart(manifest) {
+  const start = manifest == null ? void 0 : manifest.start;
+  if (!start) return null;
+  const parsed = parseAnnotationTarget(start);
+  if (!parsed.id) return null;
+  const target = { canvasId: parsed.id };
+  if (parsed.rect) target.region = parsed.rect;
+  const time = parsed.t ? Number(parsed.t.split(",")[0]) : NaN;
+  if (Number.isFinite(time)) target.time = time;
+  return target;
+}
+const hasBehavior = (resource, value) => {
+  const behavior = resource == null ? void 0 : resource.behavior;
+  return Array.isArray(behavior) ? behavior.includes(value) : behavior === value;
+};
+const partOfCollection = (manifest) => [(manifest == null ? void 0 : manifest.partOf) ?? []].flat().find((part) => (part == null ? void 0 : part.id) && part.type === "Collection");
+export {
+  canvasOfView,
+  hasBehavior,
+  partOfCollection,
+  selectCanvas,
+  selectPosition,
+  selectSequence,
+  selectStart,
+  selectVisibleCanvases
+};

package/dist/core/sequence.mjs

@@ -0,0 +1,70 @@
+"use client";
+import { asArray } from "../lib/asArray.mjs";
+const DIRECTIONS = [
+  "left-to-right",
+  "right-to-left",
+  "top-to-bottom",
+  "bottom-to-top"
+];
+function resolveDirection(declared) {
+  return DIRECTIONS.includes(declared) ? declared : "left-to-right";
+}
+const LAYOUT_BEHAVIORS = [
+  "individuals",
+  "paged",
+  "continuous",
+  "unordered"
+];
+function resolveBehavior(declared) {
+  const match = asArray(declared).find(
+    (value) => LAYOUT_BEHAVIORS.includes(value)
+  );
+  return match ?? "individuals";
+}
+function groupViews(canvases, behavior) {
+  if (!canvases.length) return [];
+  if (behavior === "continuous") return [canvases.map((_, index) => index)];
+  if (behavior !== "paged") return canvases.map((_, index) => [index]);
+  const views = [];
+  let pending = [];
+  let offset = 0;
+  let closeNextPair = false;
+  const flush = () => {
+    if (pending.length) views.push(pending);
+    pending = [];
+  };
+  canvases.forEach((canvas, index) => {
+    const own = asArray(canvas.behavior);
+    if (own.includes("non-paged")) {
+      if (index === offset) offset++;
+      flush();
+      views.push([index]);
+      return;
+    }
+    if (index === offset || own.includes("facing-pages")) {
+      if (pending.length) closeNextPair = true;
+      flush();
+      views.push([index]);
+      return;
+    }
+    pending.push(index);
+    if (closeNextPair) {
+      flush();
+      closeNextPair = false;
+      return;
+    }
+    if (pending.length > 1) flush();
+  });
+  flush();
+  return views;
+}
+function viewOf(views, canvasIndex) {
+  const found = views.findIndex((view) => view.includes(canvasIndex));
+  return found === -1 ? 0 : found;
+}
+export {
+  groupViews,
+  resolveBehavior,
+  resolveDirection,
+  viewOf
+};

package/dist/core/show-link.mjs

@@ -0,0 +1,16 @@
+"use client";
+import { selectSequence } from "./selectors.mjs";
+function showLink(clover, link) {
+  const shown = clover.store.get().manifest;
+  const here = link.canvasId && selectSequence(shown).canvases.some(
+    (canvas) => canvas.id === link.canvasId
+  );
+  if (here) clover.goTo(link.canvasId);
+  else if (link.manifestId && link.manifestId !== (shown == null ? void 0 : shown.id))
+    void clover.goToManifest(link.manifestId, link.canvasId);
+  else return false;
+  return true;
+}
+export {
+  showLink
+};

package/dist/core/store.mjs

@@ -0,0 +1,40 @@
+"use client";
+function createStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => state,
+    set(patch) {
+      const next = typeof patch === "function" ? patch(state) : patch;
+      const changed = Object.keys(next).some(
+        (key) => !Object.is(next[key], state[key])
+      );
+      if (!changed) return;
+      state = { ...state, ...next };
+      listeners.forEach((listener) => listener());
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function createChannel(initial) {
+  let value = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    get: () => value,
+    emit(next) {
+      value = next;
+      listeners.forEach((listener) => listener(next));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+export {
+  createChannel,
+  createStore
+};

package/dist/core/svg-shape.mjs

@@ -0,0 +1,183 @@
+"use client";
+const NUMBER = /^-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?$/i;
+const POINTS = /^[\d\s.,eE+-]*$/;
+const PATH = /^[\d\s.,eE+\-MmLlHhVvCcSsQqTtAaZz]*$/;
+const GEOMETRY = {
+  path: ["d"],
+  polygon: ["points"],
+  polyline: ["points"],
+  rect: ["x", "y", "width", "height", "rx", "ry"],
+  circle: ["cx", "cy", "r"],
+  ellipse: ["cx", "cy", "rx", "ry"],
+  line: ["x1", "y1", "x2", "y2"]
+};
+function readSvgShape(svg) {
+  var _a;
+  if (typeof DOMParser === "undefined" || !svg) return null;
+  let doc;
+  try {
+    doc = new DOMParser().parseFromString(svg, "image/svg+xml");
+  } catch {
+    return null;
+  }
+  if (doc.querySelector("parsererror")) return null;
+  const shapes = [];
+  const points = [];
+  for (const element of Array.from(
+    doc.querySelectorAll(Object.keys(GEOMETRY).join(","))
+  )) {
+    const tag = element.localName;
+    const attributes = {};
+    for (const name of GEOMETRY[tag]) {
+      const value = (_a = element.getAttribute(name)) == null ? void 0 : _a.trim();
+      if (value == null || value === "") continue;
+      const valid = name === "d" ? PATH.test(value) : name === "points" ? POINTS.test(value) : NUMBER.test(value);
+      if (valid) attributes[name] = value;
+    }
+    const extent = extentOf(tag, attributes);
+    if (!extent.length) continue;
+    shapes.push({ tag, attributes });
+    points.push(...extent);
+  }
+  if (!shapes.length) return null;
+  const xs = points.map(([x2]) => x2);
+  const ys = points.map(([, y2]) => y2);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  const width = Math.max(...xs) - x;
+  const height = Math.max(...ys) - y;
+  if (![x, y, width, height].every(Number.isFinite)) return null;
+  return { box: { x, y, width, height }, shapes };
+}
+const num = (attributes, name) => Number(attributes[name] ?? 0);
+function extentOf(tag, attributes) {
+  switch (tag) {
+    case "polygon":
+    case "polyline": {
+      const values = (attributes.points ?? "").trim().split(/[\s,]+/).filter(Boolean).map(Number);
+      const pairs = [];
+      for (let i = 0; i + 1 < values.length; i += 2) {
+        pairs.push([values[i], values[i + 1]]);
+      }
+      return pairs.length >= 2 ? pairs : [];
+    }
+    case "rect": {
+      const [x, y, w, h] = ["x", "y", "width", "height"].map(
+        (n) => num(attributes, n)
+      );
+      return w > 0 && h > 0 ? [
+        [x, y],
+        [x + w, y + h]
+      ] : [];
+    }
+    case "circle": {
+      const [cx, cy, r] = ["cx", "cy", "r"].map((n) => num(attributes, n));
+      return r > 0 ? [
+        [cx - r, cy - r],
+        [cx + r, cy + r]
+      ] : [];
+    }
+    case "ellipse": {
+      const [cx, cy, rx, ry] = ["cx", "cy", "rx", "ry"].map(
+        (n) => num(attributes, n)
+      );
+      return rx > 0 && ry > 0 ? [
+        [cx - rx, cy - ry],
+        [cx + rx, cy + ry]
+      ] : [];
+    }
+    case "line":
+      return [
+        [num(attributes, "x1"), num(attributes, "y1")],
+        [num(attributes, "x2"), num(attributes, "y2")]
+      ];
+    case "path":
+      return pathExtent(attributes.d ?? "");
+  }
+}
+function pathExtent(d) {
+  const tokens = d.match(
+    /[MmLlHhVvCcSsQqTtAaZz]|-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/gi
+  );
+  if (!tokens) return [];
+  const out = [];
+  let x = 0;
+  let y = 0;
+  let startX = 0;
+  let startY = 0;
+  let command = "";
+  let i = 0;
+  const next = () => Number(tokens[i++]);
+  const hasNumber = () => i < tokens.length && !/[a-z]/i.test(tokens[i]);
+  while (i < tokens.length) {
+    if (/[a-z]/i.test(tokens[i])) command = tokens[i++];
+    else if (!command) return [];
+    const relative = command === command.toLowerCase();
+    const upper = command.toUpperCase();
+    const at = (dx, dy) => relative ? [x + dx, y + dy] : [dx, dy];
+    if (upper === "Z") {
+      x = startX;
+      y = startY;
+      continue;
+    }
+    if (!hasNumber()) return out;
+    switch (upper) {
+      case "M":
+      case "L":
+      case "T": {
+        [x, y] = at(next(), next());
+        if (upper === "M") {
+          startX = x;
+          startY = y;
+          command = relative ? "l" : "L";
+        }
+        out.push([x, y]);
+        break;
+      }
+      case "H":
+        x = relative ? x + next() : next();
+        out.push([x, y]);
+        break;
+      case "V":
+        y = relative ? y + next() : next();
+        out.push([x, y]);
+        break;
+      case "C": {
+        const c1 = at(next(), next());
+        const c2 = at(next(), next());
+        [x, y] = at(next(), next());
+        out.push(c1, c2, [x, y]);
+        break;
+      }
+      case "S":
+      case "Q": {
+        const c = at(next(), next());
+        [x, y] = at(next(), next());
+        out.push(c, [x, y]);
+        break;
+      }
+      case "A": {
+        const rx = Math.abs(next());
+        const ry = Math.abs(next());
+        i += 3;
+        const from = [x, y];
+        [x, y] = at(next(), next());
+        out.push(
+          [Math.min(from[0], x) - rx, Math.min(from[1], y) - ry],
+          [Math.max(from[0], x) + rx, Math.max(from[1], y) + ry]
+        );
+        break;
+      }
+      default:
+        return out;
+    }
+    if (out.some(([px, py]) => !Number.isFinite(px) || !Number.isFinite(py))) {
+      return [];
+    }
+  }
+  return out;
+}
+export {
+  pathExtent,
+  readSvgShape
+};

package/dist/core/text.mjs

@@ -0,0 +1,36 @@
+"use client";
+const ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " "
+};
+function toPlainText(html) {
+  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]*>/g, "").replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (match, entity) => {
+    if (entity[0] === "#") {
+      const code = entity[1] === "x" || entity[1] === "X" ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+      return code > 0 && code <= 1114111 ? String.fromCodePoint(code) : match;
+    }
+    return ENTITIES[entity.toLowerCase()] ?? match;
+  });
+}
+const hasMarkup = (value) => /<[a-z!/]|&(#x?[0-9a-f]+|[a-z]+);/i.test(value);
+function readAs(format, value = "") {
+  const type = format == null ? void 0 : format.split(";")[0].trim().toLowerCase();
+  if (type) {
+    return type === "text/html" ? "html" : type === "text/markdown" ? "markdown" : "plain";
+  }
+  const text = value.trim();
+  return text.startsWith("<") && text.endsWith(">") ? "html" : "plain";
+}
+function markdownToPlainText(markdown) {
+  return markdown.replace(/\r\n?/g, "\n").replace(/^\[\^[^\]]+\]:[ \t]*/gm, "").replace(/\[\^[^\]]+\]/g, "").replace(/^#{1,6}[ \t]+(\S.*?)(?:[ \t]+#+)?[ \t]*$/gm, "$1").replace(/^[ \t]*(?:[-*+]|\d+[.)])[ \t]+/gm, "").replace(/\[([^\]]+)\]\((?:https?:\/\/|mailto:)[^\s)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*|__([^_]+)__/g, (_, a, b) => a ?? b).replace(/\*([^*\s][^*]*)\*|_([^_\s][^_]*)_/g, (_, a, b) => a ?? b).replace(/\\\n/g, "\n").replace(/\n\s*\n/g, "\n").trim();
+}
+export {
+  hasMarkup,
+  markdownToPlainText,
+  readAs,
+  toPlainText
+};

package/dist/core/thumbnail.mjs

@@ -0,0 +1,55 @@
+"use client";
+import { fetchInfo, findImageServiceId } from "../lib/renderer/sources/imageService.mjs";
+import { sizedImageUrl } from "../lib/renderer/sources/sizedImage.mjs";
+import { paintedBodies } from "./painted-bodies.mjs";
+import { asArray } from "../lib/asArray.mjs";
+function firstPaintedImage(container) {
+  var _a;
+  return (_a = paintedBodies(container).find(
+    ({ body }) => body.type === "Image" || body.id && !body.type
+  )) == null ? void 0 : _a.body;
+}
+function regionShare(region, { width, height }) {
+  if (region === "full") return { x: 0, y: 0, width: 1, height: 1 };
+  const match = /^(pct:)?([\d.]+),([\d.]+),([\d.]+),([\d.]+)$/.exec(region);
+  if (!match) return null;
+  const [x, y, w, h] = match.slice(2).map(Number);
+  const [across, down] = match[1] ? [100, 100] : [width, height];
+  return { x: x / across, y: y / down, width: w / across, height: h / down };
+}
+function imageSource(image, region = "full") {
+  if (!image) return null;
+  const service = findImageServiceId(image.service);
+  if (service) {
+    return region === "full" ? { service, fallback: image.id } : { service, region, fallback: image.id };
+  }
+  return image.id ? { src: image.id } : null;
+}
+function thumbnailSource(resource) {
+  const value = resource;
+  if (!value) return null;
+  return imageSource(asArray(value.thumbnail)[0]) ?? imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer));
+}
+function stillSource(resource) {
+  const value = resource;
+  if (!value) return null;
+  return imageSource(firstPaintedImage(value)) ?? imageSource(firstPaintedImage(value.placeholderContainer)) ?? imageSource(firstPaintedImage(value.accompanyingContainer)) ?? imageSource(asArray(value.thumbnail)[0]);
+}
+async function resolveThumbnail(source, size = 200, request) {
+  if (source.src) return source.src;
+  if (!source.service) return source.fallback;
+  try {
+    const info = await fetchInfo(source.service, { request });
+    const share = typeof source.region === "string" ? regionShare(source.region, info) : source.region;
+    if (share === null) return source.fallback;
+    return sizedImageUrl(info, size, share) ?? source.fallback;
+  } catch {
+    return source.fallback;
+  }
+}
+export {
+  imageSource,
+  resolveThumbnail,
+  stillSource,
+  thumbnailSource
+};

package/dist/core/value.mjs

@@ -0,0 +1,39 @@
+"use client";
+import { readerLanguages } from "../i18n/reader.mjs";
+const baseOf = (tag) => tag.indexOf("-") === -1 ? null : tag.slice(0, tag.indexOf("-"));
+function closestLanguage(language, tags, fallbacks = []) {
+  if (!tags.length) return void 0;
+  if (tags.length === 1) return tags[0];
+  const none = () => tags.includes("none") ? "none" : tags.includes("@none") ? "@none" : tags[0];
+  if (!language) return tags.includes("none") ? "none" : tags[0];
+  if (tags.includes(language)) return language;
+  const base = baseOf(language);
+  if (base && tags.includes(base)) return base;
+  const fallback = fallbacks.find((tag) => tags.includes(tag));
+  if (fallback) return fallback;
+  const regional = tags.findIndex((tag) => baseOf(tag) === language);
+  if (regional !== -1) return tags[regional];
+  for (const tag of fallbacks) {
+    const fallbackBase = baseOf(tag);
+    if (fallbackBase && tags.includes(fallbackBase)) return fallbackBase;
+  }
+  return none();
+}
+function localize(value, language, separator = ", ") {
+  if (!value) return { text: "" };
+  if (typeof value === "string") return { text: value };
+  const tags = Object.keys(value).filter((tag2) => {
+    var _a;
+    return (_a = value[tag2]) == null ? void 0 : _a.length;
+  });
+  if (!tags.length) return { text: "" };
+  const [first, ...rest] = language ? [language] : readerLanguages();
+  const tag = closestLanguage(first, tags, rest) ?? tags[0];
+  const entry = value[tag];
+  const text = Array.isArray(entry) ? entry.join(separator) : String(entry);
+  return { text, lang: tag === "none" ? void 0 : tag };
+}
+export {
+  closestLanguage,
+  localize
+};