@piveau/dpi 0.1.0-beta.8 → 0.1.0-beta.9

package/dist/node_modules/.pnpm/@piveau_jsonld@file_bin_piveau-jsonld-1.0.0-beta.10.tgz_jsonld@8.3.3_web-streams-polyfill@3.3.3_/node_modules/@piveau/jsonld/dist/index.js

@@ -0,0 +1,591 @@
+import { kebabCase as z } from "../../../../../change-case@5.4.4/node_modules/change-case/dist/index.js";
+import $ from "jsonld";
+import * as t from "zod/v4";
+import * as r from "zod";
+function a(e) {
+  return Array.isArray(e) ? e[0] : e;
+}
+const q = t.record(t.string(), t.string()), H = t.object({
+  "@language": t.string(),
+  "@value": t.string()
+}), l = t.preprocess(
+  (e) => typeof e == "string" ? { "@language": "de", "@value": e } : e,
+  H
+), N = t.object({
+  "@type": t.string(),
+  "@value": t.string()
+}), k = t.union([
+  t.string(),
+  N
+]), S = t.object({
+  "@id": t.string()
+}, {
+  error: (e) => {
+    if (e.code === "invalid_type")
+      return { message: `expected URI object like { "@id": "http://example.org/resource" }, received ${e.input}` };
+  }
+}), i = S, K = S, V = S, E = t.object({
+  "@id": t.string(),
+  "@type": t.union([t.literal("skos:Concept"), t.string()]),
+  "purl:identifier": t.preprocess(a, t.string().optional()),
+  prefLabel: q.optional(),
+  altLabel: q.optional(),
+  "skos:inScheme": t.preprocess(a, K.optional()),
+  "skos:notation": t.preprocess(a, V.optional())
+}), n = t.preprocess((e, s) => {
+  const o = E.partial().safeParse(e);
+  return o.success && O(o.data) && (console.warn(`Expected skos:Concept, got node reference (${o.data["@id"]}) instead. Is a JsonLdResolver missing?`), s.addIssue({
+    code: t.ZodIssueCode.custom,
+    path: ["@id"],
+    message: `Expected skos:Concept, got node reference (${o.data["@id"]}) instead. Is a JsonLdResolver missing?`,
+    fatal: !1
+  })), e;
+}, E), Z = t.object({
+  "@id": t.string(),
+  "@type": t.union([t.literal("adms:Identifier"), t.string()]),
+  "skos:notation": t.array(V).optional()
+}), Q = t.object({
+  "@type": t.literal("dcat:DataService"),
+  "dct:title": t.array(l).optional(),
+  "dct:description": t.array(l).optional(),
+  "dcat:endpointURL": t.array(t.string()).optional()
+}).passthrough(), C = t.object({
+  "@id": t.string().optional(),
+  "@type": t.string().optional(),
+  "foaf:mbox": t.preprocess(a, t.union([t.string(), i]).optional()),
+  "foaf:homepage": t.preprocess(a, t.union([t.string(), t.any()]).optional()),
+  "foaf:name": t.preprocess(a, t.string().optional()),
+  "foaf:phone": t.preprocess(a, t.string().optional())
+}), X = t.object({
+  "@id": t.string().optional(),
+  "@type": t.string().optional(),
+  "vcard:fn": t.preprocess(a, t.string().optional()),
+  "vcard:hasEmail": t.preprocess(a, t.union([t.string(), i])).optional(),
+  "vcard:hasURL": t.preprocess(a, t.union([i, t.any()]).optional()),
+  "vcard:hasTelephone": t.preprocess(a, t.union([t.string(), i]).optional())
+}), _ = t.object({
+  "@id": t.string().optional(),
+  "@type": t.string().optional(),
+  "rdfs:label": t.union([t.array(t.string()), t.record(t.string(), t.string())]).optional(),
+  "dct:title": t.union([t.array(l), t.record(t.string(), t.string())]).optional(),
+  "dct:description": t.union([t.array(l), t.record(t.string(), t.string())]).optional()
+}), Y = t.object({
+  "@value": t.string(),
+  "@type": t.string().optional()
+}), L = t.preprocess(a, t.union([
+  // Sometimes just a string? To be investigated
+  t.string(),
+  Y,
+  N
+]).optional()), tt = t.object({
+  "@id": t.string(),
+  "@type": t.literal("dcat:Distribution"),
+  "dcatap:availability": t.preprocess(a, n.optional()),
+  "dct:description": t.array(l).optional(),
+  "dct:format": t.preprocess(a, n.optional()),
+  "dcat:mediaType": t.preprocess(a, n.optional()),
+  "dct:identifier": t.array(t.string()).optional(),
+  "dct:issued": L,
+  "dct:modified": L,
+  "dct:language": t.array(n).optional(),
+  "dct:license": t.preprocess(a, n.optional()),
+  "dct:rights": t.preprocess(a, l.optional()),
+  "dct:title": t.array(l).optional(),
+  "dcat:accessURL": t.array(t.union([t.string(), i])).optional(),
+  "dcat:downloadURL": t.array(t.union([t.string(), i])).optional(),
+  "dcat:byteSize": t.preprocess(a, k.optional()),
+  "dcat:compressFormat": t.preprocess(a, n.optional()),
+  "dcat:packageFormat": t.preprocess(a, n.optional()),
+  "dcat:spatialResolutionInMeters": t.array(k).optional(),
+  "dcat:temporalResolution": t.array(k).optional(),
+  "spdx:checksum": t.preprocess(a, t.object({
+    "@type": t.string(),
+    "spdx:algorithm": t.array(t.union([n, i])).optional(),
+    "spdx:checksumValue": t.array(t.string()).optional()
+  }).optional()),
+  "dct:conformsTo": t.array(S).optional(),
+  "dct:type": t.preprocess(a, n.optional()),
+  "dcat:accessService": t.array(Q).optional(),
+  "adms:status": t.preprocess(a, n.optional()),
+  "odrl:hasPolicy": t.preprocess(a, i.optional()),
+  "dcatapde:licenseAttributionByText": t.array(l).optional()
+}), et = t.object({
+  "@id": t.string(),
+  "@type": t.literal("dcat:Dataset"),
+  // Availability and planning
+  "dcatap:availability": t.array(n).optional(),
+  "dcatap:hvdCategory": t.array(n).optional(),
+  "dcatap:applicableLegislation": t.array(i).optional(),
+  // German DCAT-AP extensions
+  "dcatapde:contributorID": t.array(n).optional(),
+  "dcatapde:geocodingDescription": t.preprocess(a, l.optional()),
+  "dcatapde:legalBasis": t.preprocess(a, l.optional()),
+  "dcatapde:politicalGeocodingLevelURI": t.array(n).optional(),
+  "dcatapde:politicalGeocodingURI": t.array(n).optional(),
+  "dcatapde:qualityProcessURI": t.array(Z).optional(),
+  // Dublin Core Terms
+  "dct:accessRights": t.preprocess(a, n.optional()),
+  "dct:accrualPeriodicity": t.preprocess(a, n.optional()),
+  "dct:alternative": t.array(l).optional(),
+  "dct:conformsTo": t.array(_).optional(),
+  "dct:created": t.array(k).optional(),
+  "dct:creator": t.preprocess(a, C.optional()),
+  "dct:contributor": t.preprocess(a, C.optional()),
+  "dct:description": t.array(l).optional(),
+  "dct:hasVersion": t.array(i).optional(),
+  "dct:identifier": t.preprocess(a, t.string().optional()),
+  "dct:isPartOf": t.array(i).optional(),
+  "dct:isReferencedBy": t.array(i).optional(),
+  "dct:isVersionOf": t.array(i).optional(),
+  "dct:issued": L,
+  "dct:modified": L,
+  "dct:language": t.array(n).optional(),
+  "dct:license": t.array(n).optional(),
+  "dct:publisher": t.preprocess(a, t.union([C.optional(), n.optional()])),
+  "dct:provenance": t.array(_).optional(),
+  "dct:relation": t.array(i).optional(),
+  "dct:rights": t.array(l).optional(),
+  "dct:rightsHolder": t.array(C).optional(),
+  "dct:source": t.array(i).optional(),
+  "dct:spatial": t.array(n).optional(),
+  "dct:subject": t.array(n).optional(),
+  "dct:temporal": t.array(t.object({
+    "@type": t.string(),
+    "dcat:startDate": t.array(k).optional(),
+    "dcat:endDate": t.array(k).optional()
+  })).optional(),
+  "dct:title": t.array(l).optional(),
+  "dct:type": t.array(n).optional(),
+  "dct:valid": t.array(k).optional(),
+  // DCAT properties
+  "dcat:contactPoint": t.array(X).optional(),
+  "dcat:distribution": t.array(tt).optional(),
+  "dcat:keyword": t.array(l).optional(),
+  "dcat:landingPage": t.array(i).optional(),
+  // 'dcat:qualifiedRelation': z.array(z.object({
+  //   '@type': z.string(),
+  //   'dct:relation': z.array(schemaNodeReference).optional(),
+  //   'dcat:hadRole': z.array(schemaSkosConcept).optional(),
+  // })).optional(),
+  "dcat:qualifiedRelation": t.array(i).optional(),
+  "dcat:theme": t.array(n).optional(),
+  "dcat:spatialResolutionInMeters": t.array(k).optional(),
+  "dcat:temporalResolution": t.array(k).optional(),
+  // FOAF properties
+  "foaf:page": t.array(i).optional(),
+  // OWL properties
+  "owl:versionInfo": t.array(t.string()).optional(),
+  // PROV properties
+  "prov:qualifiedAttribution": t.array(i).optional(),
+  "prov:wasGeneratedBy": t.array(i).optional(),
+  // Additional extension properties
+  "adms:identifier": t.array(i).optional(),
+  "adms:sample": t.array(i).optional(),
+  "adms:versionNotes": t.array(l).optional(),
+  // Piveau properties
+  "dpi:isDPIv3": t.preprocess(a, t.any())
+});
+async function W(e) {
+  try {
+    return { data: await e, error: null };
+  } catch (s) {
+    return { data: null, error: s };
+  }
+}
+const at = r.object({
+  id: r.string(),
+  resource: r.string(),
+  in_scheme: r.union([
+    r.string(),
+    r.array(r.string())
+  ]),
+  alt_label: r.record(r.string(), r.string()).optional(),
+  pref_label: r.record(r.string(), r.string()).optional()
+}), M = r.array(r.object({
+  "@language": r.string(),
+  "@value": r.string()
+}));
+r.object({
+  "@id": r.string(),
+  "@type": r.literal("http://www.w3.org/2004/02/skos/core#Concept").optional(),
+  "http://www.w3.org/2004/02/skos/core#prefLabel": M.optional(),
+  "http://www.w3.org/2004/02/skos/core#altLabel": M.optional(),
+  "http://www.w3.org/2004/02/skos/core#inScheme": r.union([
+    r.object({ "@id": r.string() }),
+    r.array(r.object({ "@id": r.string() }))
+  ]).optional(),
+  "http://purl.org/dc/elements/1.1/identifier": r.string().optional()
+});
+function rt(e) {
+  return at.safeParse(e).success;
+}
+function ot(e) {
+  const s = ([g, b]) => ({
+    "@language": g,
+    "@value": b
+  }), o = Object.entries(e.pref_label ?? {}).map(s), y = Object.entries(e.alt_label ?? {}).map(s);
+  return {
+    "@id": e.resource,
+    "@type": "http://www.w3.org/2004/02/skos/core#Concept",
+    "http://www.w3.org/2004/02/skos/core#prefLabel": o,
+    "http://www.w3.org/2004/02/skos/core#altLabel": y,
+    "http://www.w3.org/2004/02/skos/core#inScheme": G(e.in_scheme).map((g) => ({
+      "@id": g
+    })),
+    "http://purl.org/dc/elements/1.1/identifier": e.id
+  };
+}
+function G(e) {
+  return Array.isArray(e) ? [...e] : [e];
+}
+function nt(e) {
+  const { name: s, vocabularyMap: o, baseUrl: y, strict: g } = e;
+  return async ({ vocabulary: b, id: R }) => {
+    var x;
+    const h = b ?? s;
+    let w = o.get(R);
+    if (!w && y) {
+      const D = y.endsWith("/") ? "" : "/", c = new URLSearchParams();
+      c.set("resource", R);
+      const u = `${y}${D}vocabularies/${h}/vocable?${c.toString()}`, d = await W(fetch(u));
+      if (d.error) {
+        const v = `[piveau.js] Network error - Failed to fetch vocabulary '${h}' at ${u}
+${d.error}`;
+        if (g)
+          throw new Error(v);
+        return console.warn(v), null;
+      }
+      if (!d.data.ok) {
+        const v = `[piveau.js] HTTP error ${d.data.status} - Failed to fetch vocabulary '${h}' at ${u}
+${d.data.statusText}`;
+        if (console.warn(v), g)
+          throw new Error(v);
+        return null;
+      }
+      const f = await W(d.data.json());
+      if (f.error) {
+        const v = `[piveau.js] JSON error - Failed to parse vocabulary '${h}' at ${u}
+${f.error}`;
+        if (console.warn(v), g)
+          throw new Error(v);
+        return null;
+      }
+      const m = (x = f.data) == null ? void 0 : x.result;
+      if (!rt(m)) {
+        if (g)
+          throw new Error(`Vocabulary ${h} is not a Concept`);
+        return console.warn(`Vocabulary ${h} is not a Concept`, m), null;
+      }
+      const A = ot(m);
+      o.set(R, A), w = A;
+    }
+    return w || null;
+  };
+}
+function O(e) {
+  if (e === null || typeof e != "object")
+    return !1;
+  const s = e, o = Object.keys(s);
+  return o.length === 1 && o[0] === "@id" && typeof s["@id"] == "string" && !s["@id"].startsWith("_:");
+}
+async function Lt(e, s, o = {}) {
+  const {
+    skipValidation: y = !1,
+    type: g = "http://www.w3.org/ns/dcat#Dataset",
+    context: b
+  } = o, R = await $.frame(e, { "@type": g }, { embed: "@always" }), h = await $.compact(R, b ?? {
+    spdx: "http://spdx.org/rdf/terms#",
+    dcatap: "http://data.europa.eu/r5r/",
+    adms: "http://www.w3.org/ns/adms#",
+    owl: "http://www.w3.org/2002/07/owl#",
+    skos: "http://www.w3.org/2004/02/skos/core#",
+    rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+    vcard: "http://www.w3.org/2006/vcard/ns#",
+    dext: "https://data.europa.eu/ns/ext#",
+    dct: "http://purl.org/dc/terms/",
+    rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    dcatapde: "http://dcat-ap.de/def/dcatde/",
+    dcat: "http://www.w3.org/ns/dcat#",
+    prov: "http://www.w3.org/ns/prov#",
+    foaf: "http://xmlns.com/foaf/0.1/",
+    purl: "http://purl.org/dc/elements/1.1/",
+    odrl: "http://www.w3.org/ns/odrl/2/",
+    // dpi: 'https://piveau.eu/ns/dpi#',
+    prefLabel: { "@id": "skos:prefLabel", "@container": "@language" },
+    altLabel: { "@id": "skos:altLabel", "@container": "@language" }
+  }, {
+    compactArrays: !1,
+    graph: !1
+  }), w = G(h["@graph"])[0];
+  if (y)
+    return w;
+  const j = et.safeParse(w, {
+    reportInput: !0
+  });
+  if (j.success)
+    return j.data;
+  throw new Error(t.prettifyError(j.error));
+}
+function Wt(e) {
+  const {
+    resolvers: s,
+    baseUrl: o,
+    transformer: y
+  } = e, g = o != null && o.endsWith("/") ? "" : "/", b = `${o}${g}`, R = /* @__PURE__ */ new Map();
+  function h(c, u = "$", d = []) {
+    if (c === null || typeof c != "object")
+      return d;
+    if (Array.isArray(c))
+      return c.reduce((f, m, A) => h(m, `${u}[${A}]`, f), d);
+    if (O(c)) {
+      const f = c;
+      return d.push({ id: f["@id"], path: u }), d;
+    }
+    return Object.entries(c).reduce((f, [m, A]) => h(A, `${u}.${m}`, f), d);
+  }
+  async function w(c, u) {
+    const { strict: d = !1 } = u ?? {}, f = [], m = await $.expand(c), A = h(m);
+    if (await Promise.all(A.map(async ({ id: F, path: J }) => {
+      const U = { path: J, jsonld: m, vocabularyMap: R }, I = s.find((T) => T.isActive(F, U));
+      if (I) {
+        const T = nt({ name: I.name, vocabularyMap: R, baseUrl: b, strict: d }), P = await I.resolve(F, T, U);
+        P && "@id" in P && f.push(P);
+      }
+    })), f.length === 0)
+      return await $.flatten(m);
+    const v = [
+      ...m,
+      ...f
+    ], B = await $.flatten(v, {});
+    return await $.compact(B, {}, {
+      graph: !0,
+      compactArrays: !1
+    });
+  }
+  async function j(c) {
+    const u = await w(c);
+    return y ? await y(u, {
+      jsonld: u,
+      vocabularyMap: R
+    }) : u;
+  }
+  async function x(c) {
+    return W(w(c));
+  }
+  async function D(c) {
+    return W(j(c));
+  }
+  return {
+    resolve: w,
+    transform: j,
+    safeResolve: x,
+    safeTransform: D
+  };
+}
+function St(e) {
+  return e;
+}
+function p(e) {
+  return {
+    ...e,
+    resolve: async (s, o) => await o({ vocabulary: e.name, id: s })
+  };
+}
+function st() {
+  return p({
+    name: "data-theme",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/data-theme")
+  });
+}
+function it() {
+  return p({
+    name: "file-type",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/file-type")
+  });
+}
+function ct() {
+  return p({
+    name: "access-right",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/access-right")
+  });
+}
+function pt() {
+  return p({
+    name: "adms",
+    isActive: (e) => e.startsWith("http://purl.org/adms/")
+  });
+}
+function lt() {
+  return p({
+    name: "continent",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/continent")
+  });
+}
+function dt() {
+  return p({
+    name: "contributors",
+    isActive: (e) => e.startsWith("http://dcat-ap.de/def/contributors")
+  });
+}
+function ut() {
+  return p({
+    name: "frequency",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/frequency")
+  });
+}
+function yt() {
+  return p({
+    name: "hash-algorithms",
+    isActive: (e) => e.startsWith("http://dcat-ap.de/def/hashAlgorithms")
+  });
+}
+function gt() {
+  return p({
+    name: "hvd-category",
+    isActive: (e) => e.startsWith("http://data.europa.eu/bna/")
+  });
+}
+function ft() {
+  return p({
+    name: "licence",
+    isActive: (e) => e.startsWith("http://dcat-ap.de/def/licenses/")
+  });
+}
+function ht() {
+  return p({
+    name: "licenses",
+    isActive: (e) => e.startsWith("http://dcat-ap.de/def/licenses/")
+  });
+}
+function mt() {
+  return p({
+    name: "planned-availability",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/planned-availability/") || e.startsWith("http://dcat-ap.de/def/plannedAvailability/")
+  });
+}
+function wt() {
+  return p({
+    name: "iana-media-types",
+    isActive: (e) => e.startsWith("https://www.iana.org/assignments/media-types/")
+  });
+}
+function vt() {
+  return {
+    name: "political-geocoding",
+    isActive: (e) => {
+      if (!e.startsWith("http://dcat-ap.de/def/politicalGeocoding/"))
+        return !1;
+      const [s, o, y] = e.split("/").slice(-3);
+      return !!(s === "politicalGeocoding" && o && y);
+    },
+    resolve: async (e, s) => {
+      const [o, y] = e.split("/").slice(-2), b = `political-geocoding-${z(o)}`;
+      return await s({ vocabulary: b, id: e });
+    }
+  };
+}
+function bt() {
+  return p({
+    name: "country",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/country")
+  });
+}
+function Rt() {
+  return p({
+    name: "dataset-type",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/dataset-type")
+  });
+}
+function kt() {
+  return p({
+    name: "dataset-status",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/dataset-status")
+  });
+}
+function At() {
+  return p({
+    name: "language",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/language")
+  });
+}
+function jt() {
+  return p({
+    name: "distribution-type",
+    isActive: (e) => e.startsWith("http://publications.europa.eu/resource/authority/distribution-type")
+  });
+}
+function Dt() {
+  return [
+    st(),
+    it(),
+    ct(),
+    pt(),
+    lt(),
+    dt(),
+    yt(),
+    ft(),
+    ht(),
+    mt(),
+    gt(),
+    wt(),
+    Rt(),
+    kt(),
+    vt(),
+    bt(),
+    ut(),
+    At(),
+    jt()
+  ];
+}
+export {
+  ct as accessRightResolver,
+  pt as admsResolver,
+  G as asArray,
+  lt as continentResolver,
+  dt as contributorsResolver,
+  bt as countryResolver,
+  st as dataThemeResolver,
+  Dt as datasetResolvers,
+  kt as datasetStatusResolver,
+  Rt as datasetTypeResolver,
+  Lt as dcatDatasetTransformer,
+  Wt as defineJsonldResolver,
+  St as defineResolver,
+  p as defineSimpleResolver,
+  jt as distributionTypeResolver,
+  it as fileTypeResolver,
+  ut as frequencyResolver,
+  nt as generateLookupFn,
+  yt as hashAlgorithmsResolver,
+  gt as hvdCategoryResolver,
+  wt as ianaMediaTypeResolver,
+  rt as isConcept,
+  O as isNodeReference,
+  At as languageResolver,
+  ft as licenceResolver,
+  ht as licensesResolver,
+  mt as plannedAvailabilityResolver,
+  vt as politicalGeocodingResolver,
+  Z as schemaAdmsIdentifier,
+  X as schemaContactPoint,
+  Q as schemaDataService,
+  Y as schemaDate,
+  L as schemaDateField,
+  et as schemaDcatDataset,
+  tt as schemaDistribution,
+  k as schemaFlexibleValue,
+  C as schemaFoafAgent,
+  i as schemaIriString,
+  l as schemaLanguageContainer,
+  H as schemaLanguageContainerBase,
+  q as schemaMultilingualContent,
+  S as schemaNodeReference,
+  n as schemaSkosConcept,
+  E as schemaSkosConceptBase,
+  K as schemaSkosInScheme,
+  V as schemaSkosNotation,
+  _ as schemaStandard,
+  N as schemaTypedLiteral,
+  a as takeFirst,
+  ot as toConceptLd
+};

package/dist/node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.js

@@ -0,0 +1,61 @@
+const L = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu"), E = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu"), d = new RegExp("(\\d)\\p{Ll}|(\\p{L})\\d", "u"), x = /[^\p{L}\d]+/giu, i = "$1\0$2", f = "";
+function u(r) {
+  let e = r.trim();
+  e = e.replace(L, i).replace(E, i), e = e.replace(x, "\0");
+  let t = 0, c = e.length;
+  for (; e.charAt(t) === "\0"; )
+    t++;
+  if (t === c)
+    return [];
+  for (; e.charAt(c - 1) === "\0"; )
+    c--;
+  return e.slice(t, c).split(/\0/g);
+}
+function P(r) {
+  const e = u(r);
+  for (let t = 0; t < e.length; t++) {
+    const c = e[t], s = d.exec(c);
+    if (s) {
+      const l = s.index + (s[1] ?? s[2]).length;
+      e.splice(t, 1, c.slice(0, l), c.slice(l));
+    }
+  }
+  return e;
+}
+function _(r, e) {
+  const [t, c, s] = o(r, e);
+  return t + c.map(R(e == null ? void 0 : e.locale)).join((e == null ? void 0 : e.delimiter) ?? " ") + s;
+}
+function A(r, e) {
+  return _(r, { delimiter: "-", ...e });
+}
+function R(r) {
+  return r === !1 ? (e) => e.toLowerCase() : (e) => e.toLocaleLowerCase(r);
+}
+function o(r, e = {}) {
+  const t = e.split ?? (e.separateNumbers ? P : u), c = e.prefixCharacters ?? f, s = e.suffixCharacters ?? f;
+  let l = 0, a = r.length;
+  for (; l < r.length; ) {
+    const n = r.charAt(l);
+    if (!c.includes(n))
+      break;
+    l++;
+  }
+  for (; a > l; ) {
+    const n = a - 1, h = r.charAt(n);
+    if (!s.includes(h))
+      break;
+    a = n;
+  }
+  return [
+    r.slice(0, l),
+    t(r.slice(l, a)),
+    r.slice(a)
+  ];
+}
+export {
+  A as kebabCase,
+  _ as noCase,
+  u as split,
+  P as splitSeparateNumbers
+};

package/dist/{data-provider-interface → packages/dpi/src/data-provider-interface}/DPIMenu.vue.js

@@ -6,7 +6,7 @@ import A from "./components/Dropup.vue.js";
 import { useWindowScroll as T } from "@vueuse/core";
 import { resolveComponent as $, createElementBlock as m, openBlock as d, createCommentVNode as b, createVNode as p, createElementVNode as l, toDisplayString as c, withCtx as h, createTextVNode as g, Fragment as C, renderList as P, createBlock as v, resolveDynamicComponent as U, normalizeClass as q, renderSlot as O } from "vue";
 /* empty css             */
-import L from "../_virtual/_plugin-vue_export-helper.js";
+import L from "../../../../_virtual/_plugin-vue_export-helper.js";
 const z = {
   name: "DPI-menu",
   components: {

package/dist/{data-provider-interface → packages/dpi/src/data-provider-interface}/DataProviderInterface.vue.js

@@ -1,7 +1,7 @@
 import p from "./DataProviderInterface.vue2.js";
 import { resolveComponent as s, createElementBlock as n, openBlock as t, Fragment as a, createElementVNode as o, createBlock as c, createVNode as d } from "vue";
 /* empty css                           */
-import f from "../_virtual/_plugin-vue_export-helper.js";
+import f from "../../../../_virtual/_plugin-vue_export-helper.js";
 const m = {
   key: 1,
   class: "d-flex justify-content-center align-items-center",

package/dist/{data-provider-interface → packages/dpi/src/data-provider-interface}/HappyFlowComponents/BlogDPIHome.vue.js

@@ -1,6 +1,6 @@
 import { createElementBlock as n, openBlock as a, createStaticVNode as i } from "vue";
 /* empty css                 */
-import t from "../../_virtual/_plugin-vue_export-helper.js";
+import t from "../../../../../_virtual/_plugin-vue_export-helper.js";
 const r = {}, d = { class: "d-flex" };
 function s(l, e) {
   return a(), n("div", d, e[0] || (e[0] = [