arckode-ui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 underworf
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# Arckode UI
+
+Framework frontend con archivos `.ark` (Single File Components), reactividad por signals, compiler propio (Vite plugin), router file-system y analyzer estático.
+
+> **Diseñado para máxima predictibilidad de output de IA.** Hay un solo camino correcto para cada problema. Para cada violation detectada, el analyzer sugiere el fix concreto.
+
+**Versión:** 0.1.0 — desarrollo activo
+
+---
+
+## Instalación
+
+```bash
+bun add arckode-ui
+# o
+npm install arckode-ui
+```
+
+## Setup mínimo
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { arkcodeUi } from 'arckode-ui/vite'
+
+export default defineConfig({
+  plugins: [arkcodeUi()],
+})
+```
+
+```typescript
+// src/main.ts
+import { mount } from 'arckode-ui'
+import App from './App.ark'
+
+mount(App, '#app')
+```
+
+## Tu primer componente — `App.ark`
+
+```html
+<template>
+  <div>
+    <h1>{{ state.message.value }}</h1>
+    <button @click="actions.toggle">{{ computed.buttonLabel.value }}</button>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent, signal, computed } from 'arckode-ui'
+
+export default defineComponent({
+  name: 'App',
+  props: {},
+  emits: [],
+  setup(props, { emit }) {
+    const message = signal('Hola Arckode')
+    const buttonLabel = computed(() => message.value === 'Hola Arckode' ? 'Chau' : 'Hola')
+
+    function toggle() {
+      message.value = message.value === 'Hola Arckode' ? 'Chau Arckode' : 'Hola Arckode'
+    }
+
+    return {
+      state: { message },
+      computed: { buttonLabel },
+      actions: { toggle },
+    }
+  },
+})
+</script>
+```
+
+## CLI
+
+```bash
+ark new mi-app                           # scaffold proyecto nuevo
+ark generate component UserCard          # → src/components/features/UserCard.ark
+ark generate page about                  # → src/pages/about.ark
+ark generate page users/[id]             # → src/pages/users/[id].ark
+ark generate store cart                  # → src/stores/cart.store.ts
+ark generate service Product             # → src/services/product.service.ts
+ark generate layout users                # → src/pages/users/_layout.ark
+ark analyze [--json]                     # detecta violations en archivos .ark
+ark routes                               # lista rutas detectadas en src/pages/
+```
+
+Aliases del generator: `c` (component), `p` (page), `s` (store), `sv` (service), `l` (layout).
+
+## Reactividad — Signals
+
+```typescript
+import { signal, computed, watch, effect } from 'arckode-ui'
+
+const count = signal(0)
+count.value = 5            // set — dispara re-render
+count.value                // get — suscribe al efecto activo
+count.peek                 // get sin suscribirse
+
+const double = computed(() => count.value * 2)
+double.value               // readonly — recalcula al cambiar count
+
+watch(count, (newVal, oldVal) => { /* ... */ })
+effect(() => { document.title = `${count.value}` })
+```
+
+## Directivas del template
+
+| Necesito | Sintaxis |
+|----------|----------|
+| Texto dinámico | `{{ state.x.value }}` / `{{ computed.x.value }}` / `{{ props.x }}` |
+| Atributo dinámico | `:value="state.x.value"` / `:class="..."` |
+| Evento | `@click="actions.handler"` |
+| Evento con argumento | `@click="actions.toggle(item.id)"` |
+| Tecla modificadora | `@keydown.enter="actions.search"` |
+| Condicional | `v-if="..."` + `v-else-if="..."` + `v-else` |
+| Visibilidad (sin desmontar) | `v-show="state.x.value"` |
+| Lista | `v-for="item in state.items.value"` |
+| Componente hijo | `<MiComponente :prop="state.x.value" />` |
+| Slot (en wrapper) | `<slot />` |
+
+## El analyzer — `ark analyze`
+
+Detecta 16 violations comunes. Cada violation incluye un campo `fix` con la sugerencia concreta:
+
+```
+[arckode-ui] UserCard.ark:5
+  HANDLER_NOT_IN_ACTIONS: El handler "handleClick" no está namespaced.
+
+  > 5 | <button @click="handleClick">
+  Fix: Reemplazar "handleClick" por "actions.handleClick" y asegurarse de que la función esté declarada en setup() y exportada en el return.actions.
+```
+
+Reglas principales:
+- `MISSING_TEMPLATE`, `MISSING_SCRIPT`, `MISSING_LANG_TS`, `WRONG_TEMPLATE_ORDER`
+- `MISSING_COMPONENT_NAME`, `PROP_MISSING_TYPE`, `EMIT_CAMELCASE`
+- `REF_REACTIVE_USAGE`, `PROVIDE_INJECT_USAGE`, `DIRECT_FETCH_IN_COMPONENT`
+- `LOGIC_IN_TEMPLATE`, `ARROW_FUNCTION_ACTION`
+- `HANDLER_NOT_IN_ACTIONS`, `VFOR_NOT_NAMESPACED`, `VIF_NOT_NAMESPACED`
+- `SETUP_UNKNOWN_RETURN_KEY`
+
+## Ejemplos incluidos
+
+- `examples/kitchen-sink/` — demo de todas las directivas y primitivas
+- `examples/tasks/` — app real de tareas con sidebar, modal, form, validación, search con debounce
+
+Correr cualquiera:
+```bash
+cd examples/tasks && bun install && bun dev
+```
+
+## Documentación para IA
+
+- `CLAUDE.md` (en este repo) — instrucciones para Claude/OpenCode al desarrollar el framework
+- `~/.claude/skills/arckode-ui/SKILL.md` — guía completa para usar el framework
+
+## Stack
+
+- TypeScript estricto
+- Vite (build + dev server)
+- Vitest + happy-dom (tests)
+- Bun (package manager recomendado)
+
+## Estado
+
+312 tests pasando · 16 reglas del analyzer · 7 componentes en el ejemplo `tasks`.
+
+## Licencia
+
+MIT

package/dist/analyzer-Ctnj3WTI.js

@@ -0,0 +1,424 @@
+function u(e, i) {
+  return e.slice(0, i).split(`
+`).length;
+}
+function S(e) {
+  return e.split(`
+`);
+}
+function O(e) {
+  return /<template[\s>]/i.test(e) ? null : {
+    code: "MISSING_TEMPLATE",
+    severity: "error",
+    line: 1,
+    message: "El componente no tiene sección <template>.",
+    fix: "Agregar <template>...</template> al principio del archivo, antes de <script>."
+  };
+}
+function $(e) {
+  return /<script[\s>]/i.test(e) ? null : {
+    code: "MISSING_SCRIPT",
+    severity: "error",
+    line: 1,
+    message: "El componente no tiene sección <script>.",
+    fix: 'Agregar <script lang="ts">...<\/script> después de </template>.'
+  };
+}
+function N(e) {
+  const i = e.match(/<script([^>]*)>/i);
+  if (i) {
+    const t = i[1] ?? "";
+    if (!/lang=["']ts["']/.test(t)) {
+      const n = e.indexOf(i[0]);
+      return {
+        code: "MISSING_LANG_TS",
+        severity: "error",
+        line: u(e, n),
+        message: 'La sección <script> debe tener lang="ts".',
+        fix: 'Reemplazar <script> por <script lang="ts">.'
+      };
+    }
+  }
+  return null;
+}
+function I(e) {
+  const i = e.search(/<script[\s>]/i), t = e.search(/<template[\s>]/i);
+  return i !== -1 && t !== -1 && i < t ? {
+    code: "WRONG_TEMPLATE_ORDER",
+    severity: "error",
+    line: u(e, i),
+    message: "<script> aparece antes que <template>. El orden correcto es <template> primero.",
+    fix: "Mover la sección <template>...</template> arriba, antes de <script>."
+  } : null;
+}
+function g(e) {
+  const i = e.match(/<template[^>]*>([\s\S]*?)<\/template>/i);
+  if (!i) return null;
+  const t = i[1], n = e.indexOf(i[0]) + i[0].indexOf(t), s = u(e, n) - 1;
+  return { content: t, lineOffset: s };
+}
+function E(e) {
+  const i = [];
+  let t = 0, n = 0;
+  for (; n < e.length; ) {
+    const s = e[n];
+    if (s === "/" && e[n + 1] === "/") {
+      for (; n < e.length && e[n] !== `
+`; ) n++;
+      continue;
+    }
+    if (s === "/" && e[n + 1] === "*") {
+      for (n += 2; n < e.length && !(e[n] === "*" && e[n + 1] === "/"); ) n++;
+      n += 2;
+      continue;
+    }
+    if (s === '"' || s === "'" || s === "`") {
+      const o = s;
+      for (n++; n < e.length && e[n] !== o; )
+        e[n] === "\\" && n++, n++;
+      n++;
+      continue;
+    }
+    if (s === "{" || s === "[" || s === "(") {
+      t++, n++;
+      continue;
+    }
+    if (s === "}" || s === "]" || s === ")") {
+      t--, n++;
+      continue;
+    }
+    if (t === 0) {
+      const o = /^([a-zA-Z_$][\w$]*)\s*:/.exec(e.slice(n));
+      if (o && o[1]) {
+        i.push(o[1]), n += o[0].length;
+        continue;
+      }
+    }
+    n++;
+  }
+  return i;
+}
+function x(e, i) {
+  const t = e.indexOf("{", i);
+  if (t === -1) return null;
+  let n = 0, s = t;
+  for (; s < e.length; ) {
+    if (e[s] === "{") n++;
+    else if (e[s] === "}" && (n--, n === 0))
+      return { content: e.slice(t + 1, s), start: t, end: s };
+    s++;
+  }
+  return null;
+}
+function w(e) {
+  const i = [], n = /\bprops\s*:\s*\{/g.exec(e);
+  if (!n) return i;
+  const s = n.index + n[0].length - 1, o = x(e, s);
+  if (!o) return i;
+  const c = o.content, r = /(\w+)\s*:\s*\{/g;
+  let a;
+  for (; (a = r.exec(c)) !== null; ) {
+    const p = a[1], l = o.start + 1 + a.index + a[0].length - 1, d = x(e, l);
+    if (!d) continue;
+    const h = d.content;
+    if (!/\btype\s*:/.test(h)) {
+      const f = o.start + 1 + a.index;
+      i.push({
+        code: "PROP_MISSING_TYPE",
+        severity: "error",
+        line: u(e, f),
+        message: `La prop "${p}" no tiene "type" definido.`,
+        fix: `${p}: { type: String, required: true } — reemplazar String por el tipo correcto (String, Number, Boolean, Array, Object, Function).`
+      });
+    }
+  }
+  return i;
+}
+function C(e) {
+  const i = [], t = e.match(/emits\s*:\s*\[([\s\S]*?)\]/);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]), o = /['"]([^'"]+)['"]/g;
+  let c;
+  for (; (c = o.exec(n)) !== null; ) {
+    const r = c[1];
+    if (/^[a-z][a-zA-Z]*[A-Z][a-zA-Z]*$/.test(r)) {
+      const a = r.replace(/([A-Z])/g, (l) => `-${l.toLowerCase()}`), p = s + t[0].indexOf(c[0]);
+      i.push({
+        code: "EMIT_CAMELCASE",
+        severity: "error",
+        line: u(e, p),
+        message: `El evento "${r}" debe ser kebab-case: "${a}".`,
+        fix: `Reemplazar '${r}' por '${a}' en emits[] y en cada emit() / @${a}="..." del template.`
+      });
+    }
+  }
+  return i;
+}
+function y(e) {
+  const i = [], t = e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = [
+    { re: /\bref\s*\(/g, name: "ref()" },
+    { re: /\breactive\s*\(/g, name: "reactive()" }
+  ];
+  for (const { re: c, name: r } of o) {
+    let a;
+    for (; (a = c.exec(n)) !== null; )
+      i.push({
+        code: "REF_REACTIVE_USAGE",
+        severity: "error",
+        line: u(e, s + a.index),
+        message: `Uso de ${r} detectado. Usar signal() en lugar de ref()/reactive().`,
+        fix: `Reemplazar ${r} por signal(). Si era reactive({a, b}), declarar un signal por cada propiedad. Importar signal desde 'arckode-ui'.`
+      });
+  }
+  return i;
+}
+function A(e) {
+  const i = [], t = e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = [
+    { re: /\bprovide\s*\(/g, name: "provide()" },
+    { re: /\binject\s*\(/g, name: "inject()" }
+  ];
+  for (const { re: c, name: r } of o) {
+    let a;
+    for (; (a = c.exec(n)) !== null; )
+      i.push({
+        code: "PROVIDE_INJECT_USAGE",
+        severity: "error",
+        line: u(e, s + a.index),
+        message: `Uso de ${r} detectado. Arckode UI no usa provide/inject — usar conectores o props.`,
+        fix: `Eliminar la llamada a ${r}. Pasar el valor por props si es padre→hijo, o usar estado global (defineStore) si son componentes sin relación.`
+      });
+  }
+  return i;
+}
+function b(e) {
+  const i = [], t = e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = /\bfetch\s*\(/g;
+  let c;
+  for (; (c = o.exec(n)) !== null; )
+    i.push({
+      code: "DIRECT_FETCH_IN_COMPONENT",
+      severity: "error",
+      line: u(e, s + c.index),
+      message: "fetch() directo en el componente. Mover la lógica de red a un servicio externo.",
+      fix: "Crear un service en src/services/{dominio}.service.ts con createService() y llamarlo desde una action o desde onMount."
+    });
+  return i;
+}
+function _(e) {
+  const i = /defineComponent\s*\(\s*\{([\s\S]*?)\}\s*\)/, t = e.match(i);
+  if (!t) return null;
+  const n = t[1];
+  if (!/\bname\s*:/.test(n)) {
+    const s = e.indexOf(t[0]);
+    return {
+      code: "MISSING_COMPONENT_NAME",
+      severity: "error",
+      line: u(e, s),
+      message: 'defineComponent() no tiene "name" definido. Agregar name: "NombreComponente".',
+      fix: `Agregar "name: 'NombreEnPascalCase'," como primera propiedad de defineComponent({...}). Usar el mismo nombre del archivo.`
+    };
+  }
+  return null;
+}
+function M(e) {
+  const i = [], t = e.match(/<template[^>]*>([\s\S]*?)<\/template>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = n.split(`
+`);
+  let c = u(e, s) - 1;
+  const r = /(?:@\w[\w.]*|v-if|v-show|v-for|:[a-z][\w-]*)="([^"]+)"/g;
+  for (let a = 0; a < o.length; a++) {
+    const p = o[a];
+    let l;
+    for (r.lastIndex = 0; (l = r.exec(p)) !== null; ) {
+      const d = l[1];
+      if (/\+\+|--|\?[^:]|[^?]:/.test(d) && /\+\+|--|[^=!<>?]\s*\?/.test(d)) {
+        i.push({
+          code: "LOGIC_IN_TEMPLATE",
+          severity: "error",
+          line: c + a + 1,
+          message: `Expresión compleja en directiva: "${d}". Mover la lógica a computed o action.`,
+          fix: "Crear un action (function declaration) en setup() que ejecute esta lógica y referenciarlo como actions.nombreDelAction. Si es un valor derivado, usar computed."
+        });
+        break;
+      }
+    }
+  }
+  return i;
+}
+function R(e) {
+  const i = [], t = e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = n.match(/actions\s*:\s*\{([\s\S]*?)\}/);
+  if (!o) return i;
+  const c = o[1], r = n.indexOf(o[0]), a = /(\w+)\s*:\s*(?:\([^)]*\)|[a-zA-Z_$][\w$]*)\s*=>/g;
+  let p;
+  for (; (p = a.exec(c)) !== null; ) {
+    const f = s + r + o[0].indexOf(p[0]), m = p[1];
+    i.push({
+      code: "ARROW_FUNCTION_ACTION",
+      severity: "warning",
+      line: u(e, f),
+      message: `La action "${m}" está definida como arrow function. Usar function declaration.`,
+      fix: `Declarar como "function ${m}(...) { ... }" en setup() y pasarla por shorthand: actions: { ${m} }.`
+    });
+  }
+  const l = /const\s+(\w+)\s*=\s*(?:\([^)]*\)|[a-zA-Z_$][\w$]*)\s*=>/g;
+  l.lastIndex = 0;
+  const d = n.match(/actions\s*:\s*\{([^}]*)\}/);
+  if (!d) return i;
+  const h = d[1].split(",").map((f) => f.trim()).filter(Boolean);
+  for (; (p = l.exec(n)) !== null; ) {
+    const f = p[1];
+    if (h.includes(f)) {
+      const m = s + p.index;
+      i.push({
+        code: "ARROW_FUNCTION_ACTION",
+        severity: "warning",
+        line: u(e, m),
+        message: `La action "${f}" está definida como arrow function. Usar function declaration.`,
+        fix: `Reemplazar "const ${f} = (...) => ..." por "function ${f}(...) { ... }".`
+      });
+    }
+  }
+  return i;
+}
+function T(e) {
+  const i = [], t = g(e);
+  if (!t) return i;
+  const { content: n, lineOffset: s } = t, o = n.split(`
+`), c = /@[\w.]+="([^"]+)"/g;
+  for (let r = 0; r < o.length; r++) {
+    const a = o[r];
+    c.lastIndex = 0;
+    let p;
+    for (; (p = c.exec(a)) !== null; ) {
+      const l = p[1].trim();
+      l.startsWith("actions.") || i.push({
+        code: "HANDLER_NOT_IN_ACTIONS",
+        severity: "error",
+        line: s + r + 1,
+        message: `El handler "${l}" no está namespaced. Usar actions.handlerName en lugar de llamadas directas.`,
+        fix: k(l)
+      });
+    }
+  }
+  return i;
+}
+function k(e) {
+  if (/\+\+|--|=(?!=)/.test(e))
+    return `Crear una function action en setup() (ej: function handleClick() { ${e} }) y referenciarla como actions.handleClick.`;
+  const i = e.startsWith("actions.") ? e : `actions.${e}`;
+  return `Reemplazar "${e}" por "${i}" y asegurarse de que la función esté declarada en setup() y exportada en el return.actions.`;
+}
+function L(e) {
+  const i = [], t = g(e);
+  if (!t) return i;
+  const { content: n, lineOffset: s } = t, o = n.split(`
+`), c = /v-for="([^"]+)"/g, r = ["state.", "computed.", "props."];
+  for (let a = 0; a < o.length; a++) {
+    const p = o[a];
+    c.lastIndex = 0;
+    let l;
+    for (; (l = c.exec(p)) !== null; ) {
+      const d = l[1].trim(), h = /^(?:\([^)]+\)|\w+)\s+in\s+(.+)$/.exec(d);
+      if (!h) continue;
+      const f = h[1].trim();
+      if (!r.some((m) => f.startsWith(m))) {
+        const m = d.slice(0, d.indexOf(" in")).trim(), v = /^\w+$/.test(f) ? `v-for="${m} in state.${f}.value"  // o computed.${f}.value / props.${f}` : `v-for="${m} in state.<nombreDelSignal>.value"  // mover "${f}" a un signal o computed en setup()`;
+        i.push({
+          code: "VFOR_NOT_NAMESPACED",
+          severity: "error",
+          line: s + a + 1,
+          message: `v-for colección "${f}" no está namespaced. Usar state.xxx, computed.xxx o props.xxx.`,
+          fix: v
+        });
+      }
+    }
+  }
+  return i;
+}
+function U(e) {
+  const i = [], t = g(e);
+  if (!t) return i;
+  const { content: n, lineOffset: s } = t, o = n.split(`
+`), c = /v-(?:if|else-if)="([^"]+)"/g;
+  for (let r = 0; r < o.length; r++) {
+    const a = o[r];
+    c.lastIndex = 0;
+    let p;
+    for (; (p = c.exec(a)) !== null; ) {
+      const l = p[1].trim();
+      if (!l.includes(".")) {
+        const d = l.startsWith("!") ? l.slice(1).trim() : l, h = l.startsWith("!"), f = /^\w+$/.test(d) ? `v-if="${h ? "!" : ""}state.${d}.value"  // o computed.${d}.value` : 'v-if="state.<nombreDelSignal>.value"  // mover la expresión a un computed en setup()';
+        i.push({
+          code: "VIF_NOT_NAMESPACED",
+          severity: "warning",
+          line: s + r + 1,
+          message: `v-if "${l}" parece un identificador sin namespace. Usar state.xxx.value, computed.xxx.value o props.xxx.`,
+          fix: f
+        });
+      }
+    }
+  }
+  return i;
+}
+function P(e) {
+  const i = [], t = e.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+  if (!t) return i;
+  const n = t[1], s = e.indexOf(t[0]) + t[0].indexOf(n), o = /* @__PURE__ */ new Set(["state", "computed", "actions"]), c = /\breturn\s*\{/g;
+  let r;
+  for (; (r = c.exec(n)) !== null; ) {
+    const a = r.index + r[0].lastIndexOf("{"), p = s + a, l = x(e, p);
+    if (!l) continue;
+    const d = E(l.content), h = d.some((m) => o.has(m)), f = d.filter((m) => !o.has(m));
+    if (h && f.length > 0)
+      for (const m of f)
+        i.push({
+          code: "SETUP_UNKNOWN_RETURN_KEY",
+          severity: "error",
+          line: u(e, l.start),
+          message: `La llave "${m}" no es válida en el return de setup(). Solo se permiten: state, computed, actions.`,
+          fix: `Quitar "${m}: ..." del return. Si era estado, mover a state. Si era función, mover a actions. Si era valor derivado, mover a computed.`
+        });
+  }
+  return i;
+}
+function D(e, i) {
+  const t = [], n = {
+    template: !/<template[\s>]/i.test(e),
+    script: !/<script[\s>]/i.test(e)
+  }, s = O(e);
+  s && t.push(s);
+  const o = $(e);
+  if (o && t.push(o), !n.script) {
+    const c = N(e);
+    c && t.push(c);
+  }
+  if (!n.template && !n.script) {
+    const c = I(e);
+    c && t.push(c);
+  }
+  if (!n.script) {
+    const c = _(e);
+    c && t.push(c), t.push(...w(e)), t.push(...C(e)), t.push(...y(e)), t.push(...A(e)), t.push(...b(e)), t.push(...R(e));
+  }
+  return n.template || (t.push(...M(e)), t.push(...T(e)), t.push(...L(e)), t.push(...U(e))), n.script || t.push(...P(e)), t;
+}
+function F(e, i, t) {
+  const n = i.split("/").pop() ?? i, o = S(t)[e.line - 1] ?? "", c = e.fix !== void 0 ? `
+  Fix: ${e.fix}` : "";
+  return `[arckode-ui] ${n}:${e.line}
+  ${e.code}: ${e.message}
+
+  > ${e.line} | ${o}` + c;
+}
+export {
+  D as a,
+  F as f
+};