@fluixi/compiler 1.0.0-alpha.100

package/dist/vite-styles.js

@@ -0,0 +1,241 @@
+/**
+ * Component styles in a Vite build: the orchestration around the compiler's style pass.
+ *
+ * The CSS engine is reached through another plugin's `api.fluixiCss` (@fluixi-css/vite), which
+ * owns the project's shared context; the compiler owns ownership and scoping; this file only
+ * connects them. Each compiled block becomes a CSS module the component imports, so Vite's own
+ * CSS pipeline does the rest: extraction, chunking, dev style tags, hot updates, and the
+ * stylesheets @fluixi/start puts in server-rendered pages.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, dirname, extname, join, relative } from 'node:path';
+import { styleIds } from './transform/styles.js';
+// A page stylesheet, or (`?inline`, Vite's own flag) a shadow root's CSS as a string; and a
+// css`` value's CSS for a shadow class's `static styles`. The owner is what comes before.
+const STYLE_ID = /\.fx-(\d+)\.css(?:\?inline)?$/;
+const LITERAL_ID = /\.fx-literal-([\w$]+)\.css\?inline$/;
+const SUFFIX = /\.fx-(?:\d+|literal-[\w$]+)\.css(?:\?inline)?$/;
+/** The id a component's n-th style block is served under: a CSS request Vite treats as such. */
+export const styleId = styleIds.block;
+/** The source name the first positioned node carries: the module a value was written in. */
+function firstLoc(nodes) {
+    for (const node of nodes) {
+        if (node.loc)
+            return node.loc.source;
+        if ((node.kind === 'rule' || node.kind === 'at-rule') && node.nodes.length) {
+            const inner = firstLoc(node.nodes);
+            if (inner)
+                return inner;
+        }
+    }
+    return undefined;
+}
+/** The component a style id belongs to, as written in the id. */
+const ownerOf = (id) => id.slice(0, id.search(SUFFIX));
+// The same loader @fluixi-ui/tokens ships beside each slice: one <link>, added once.
+const loader = (name) => `const href = new URL(${JSON.stringify(`./${name}`)}, import.meta.url).href;
+if (typeof document !== 'undefined' && !document.querySelector(\`link[data-fx-css="\${href}"]\`)) {
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.href = href;
+  link.dataset.fxCss = href;
+  document.head.appendChild(link);
+}
+`;
+export function createComponentStyles(compile) {
+    let api;
+    let server;
+    let root = process.cwd();
+    // A library build (`build.lib`): the directory its entry is in, which its output mirrors.
+    let library;
+    // What a library build writes: the file under the output directory, and its CSS.
+    const emitted = new Map();
+    // A module id is a file path, or, for modules a plugin imports by URL (`/src/routes/…`),
+    // a path from the project root.
+    const fileOf = (id) => (existsSync(id) ? id : join(root, id));
+    // The CSS of each module's blocks, with the source it came from, for `load` and for telling
+    // what changed.
+    const cache = new Map();
+    const resolveReference = async (ref, importer, ctx, seen, modules) => {
+        const resolved = await ctx.resolve?.(ref.source, importer);
+        if (!resolved)
+            return null;
+        const file = resolved.id.split('?')[0];
+        if (seen.has(file))
+            return null;
+        let code;
+        try {
+            code = readFileSync(fileOf(file), 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const styles = api.styles(file);
+        let result = compile(code, file, styles);
+        // A value that composes values from further away: those first.
+        if (result?.styleReferences?.length) {
+            const imported = await resolveAll(result.styleReferences, file, ctx, new Set([...seen, file]), modules);
+            result = compile(code, file, { ...styles, imported, importedModules: modules });
+        }
+        const literal = result?.styleLiterals?.find((l) => l.name === ref.name);
+        if (!literal)
+            return null;
+        // Its rules as written, positions in its own module, which the composing block's map names.
+        const nodes = literal.nodes ?? styles.process(literal.css, file);
+        const named = firstLoc(nodes);
+        if (named)
+            modules.set(named, { id: file, code });
+        return nodes;
+    };
+    const resolveAll = async (refs, importer, ctx, seen, modules) => {
+        const imported = new Map();
+        for (const ref of refs) {
+            const nodes = await resolveReference(ref, importer, ctx, seen, modules);
+            if (nodes)
+                imported.set(`${ref.source}#${ref.name}`, nodes);
+        }
+        return imported;
+    };
+    const run = async (code, id, ctx) => {
+        // One name per file, whatever id it was reached by (`/src/…` from a plugin, an absolute
+        // path from `load`): the scope id is derived from it, and the elements and the CSS have to
+        // agree on it.
+        const file = fileOf(id);
+        const styles = api.styles(file);
+        let result = compile(code, file, styles);
+        if (result?.styleReferences?.length) {
+            const modules = new Map();
+            const imported = await resolveAll(result.styleReferences, id, ctx, new Set([file]), modules);
+            result = compile(code, file, { ...styles, imported, importedModules: modules });
+        }
+        const css = (result?.styles ?? []).map((s) => s.css);
+        const maps = (result?.styles ?? []).map((s) => s.map ?? null);
+        const literals = new Map((result?.styleLiterals ?? []).map((l) => [l.name, l.css]));
+        const before = cache.get(file);
+        cache.set(file, { source: code, css, maps, literals });
+        // A block whose CSS changed (its own edit, or a value it composes from another module) is
+        // reloaded: its module id did not change, so nothing else would tell Vite.
+        if (server && before) {
+            for (let i = 0; i < css.length; i++) {
+                if (before.css[i] === css[i])
+                    continue;
+                const mod = server.moduleGraph.getModuleById(styleId(file, i));
+                if (mod)
+                    void server.reloadModule(mod);
+            }
+        }
+        // Page stylesheets are imported for their effect; a shadow element's blocks already reach
+        // its class through the `?inline` imports the compiler wrote.
+        const page = (result?.styles ?? []).flatMap((s, i) => (s.shadow ? [] : [i]));
+        if (!result || page.length === 0)
+            return result;
+        if (library) {
+            // A package ships a module's CSS as one file next to it, its blocks in source order,
+            // imported relatively: any bundler that takes a `.css` import takes it, and nothing in
+            // it needs this plugin. The `.css.js` beside it is for a page with no bundler: an import
+            // map points the stylesheet's url at it, and it adds the sheet as a <link>.
+            const name = `${basename(file, extname(file))}.css`;
+            if (existsSync(join(dirname(file), name))) {
+                throw new Error(`[fluixi] ${file} has <style> blocks, and ${name} next to it would be overwritten by their CSS. Rename one of them.`);
+            }
+            const out = join(relative(library, dirname(file)), name);
+            emitted.set(out, page.map((i) => css[i]).join('\n'));
+            emitted.set(`${out}.js`, loader(name));
+            return { ...result, code: `${result.code}\nimport ${JSON.stringify(`./${name}`)};` };
+        }
+        const imports = page.map((i) => `\nimport ${JSON.stringify(styleId(file, i))};`).join('');
+        return { ...result, code: result.code + imports };
+    };
+    return {
+        /** Looks for @fluixi-css/vite among the plugins; without it component styles stay off. */
+        connect(plugins, projectRoot) {
+            if (projectRoot)
+                root = projectRoot;
+            api = (plugins ?? [])
+                .map((p) => p?.api?.fluixiCss)
+                .find((a) => Boolean(a));
+            api?.useComponentStyles();
+        },
+        /** Turns on library output, from the directory of a `build.lib` entry. */
+        setLibrary(entryDir) {
+            library = entryDir;
+        },
+        /** A library build's style import: left for the package's consumer to bundle. */
+        isLibraryImport(id, importer) {
+            if (library === undefined || !importer || !id.startsWith('./') || !id.endsWith('.css'))
+                return false;
+            return emitted.has(join(relative(library, dirname(fileOf(importer))), id));
+        },
+        /** The style files a library build writes, by path under the output directory. */
+        libraryFiles() {
+            return emitted;
+        },
+        get active() {
+            return api !== undefined;
+        },
+        setServer(dev) {
+            server = dev;
+        },
+        isStyle(id) {
+            return STYLE_ID.test(id) || LITERAL_ID.test(id);
+        },
+        /**
+         * A style request as the module id Vite keeps: its owner's absolute path, then the suffix.
+         * One id per block however it was asked for (`/src/card.tsx.fx-0.css` from a page, the
+         * absolute path from the component), or the reload after an edit misses the copy in use.
+         * A css`` value imported from another module names that module relatively, as written.
+         */
+        async resolveId(id, importer, ctx) {
+            const at = id.search(SUFFIX);
+            const owner = id.slice(0, at);
+            if (!owner.startsWith('.'))
+                return fileOf(owner) + id.slice(at);
+            const resolved = importer ? await ctx.resolve?.(owner, importer) : null;
+            return resolved ? resolved.id.split('?')[0] + id.slice(at) : null;
+        },
+        /**
+         * The style modules of a changed file, for the update Vite sends. Their ids do not name the
+         * file (they end in `.css`), so Vite would not find them itself.
+         */
+        hotModules(file, graph) {
+            const entry = cache.get(file);
+            if (!entry)
+                return [];
+            const paths = [
+                ...entry.css.map((_, i) => styleId(file, i)),
+                ...[...entry.literals.keys()].map((name) => styleIds.literal(file, name).replace(/\?inline$/, '')),
+            ];
+            return paths.flatMap((path) => [...(graph.getModulesByFile(path) ?? [])]);
+        },
+        compile: run,
+        /**
+         * A block's CSS and its map back to the module, compiling the module again when the cache
+         * does not match the file.
+         */
+        async load(id, ctx) {
+            const match = STYLE_ID.exec(id);
+            const literal = LITERAL_ID.exec(id);
+            if ((!match && !literal) || !api)
+                return null;
+            const file = ownerOf(id);
+            let source;
+            try {
+                source = readFileSync(fileOf(file), 'utf8');
+            }
+            catch {
+                return null;
+            }
+            if (cache.get(fileOf(file))?.source !== source)
+                await run(source, file, ctx);
+            const entry = cache.get(fileOf(file));
+            if (literal) {
+                const css = entry?.literals.get(literal[1]);
+                if (css === undefined)
+                    throw new Error(`[fluixi] ${literal[1]} in ${file} is not a css\`\` value, so it cannot be a shadow root's styles.`);
+                return { code: css, map: null, moduleType: 'css' };
+            }
+            const index = Number(match[1]);
+            return { code: entry?.css[index] ?? '', map: entry?.maps[index] ?? null, moduleType: 'css' };
+        },
+    };
+}

package/dist/vite-styles.mjs

@@ -0,0 +1,214 @@
+// src/vite-styles.ts
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative } from "node:path";
+
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+var bufLength = 1024 * 16;
+
+// src/transform/styles.ts
+var styleIds = {
+  block: (owner, index) => `${owner}.fx-${index}.css`,
+  inline: (owner, index) => `${owner}.fx-${index}.css?inline`,
+  literal: (owner, name) => `${owner}.fx-literal-${name}.css?inline`
+};
+
+// src/vite-styles.ts
+var STYLE_ID = /\.fx-(\d+)\.css(?:\?inline)?$/;
+var LITERAL_ID = /\.fx-literal-([\w$]+)\.css\?inline$/;
+var SUFFIX = /\.fx-(?:\d+|literal-[\w$]+)\.css(?:\?inline)?$/;
+var styleId = styleIds.block;
+function firstLoc(nodes) {
+  for (const node of nodes) {
+    if (node.loc) return node.loc.source;
+    if ((node.kind === "rule" || node.kind === "at-rule") && node.nodes.length) {
+      const inner = firstLoc(node.nodes);
+      if (inner) return inner;
+    }
+  }
+  return void 0;
+}
+var ownerOf = (id) => id.slice(0, id.search(SUFFIX));
+var loader = (name) => `const href = new URL(${JSON.stringify(`./${name}`)}, import.meta.url).href;
+if (typeof document !== 'undefined' && !document.querySelector(\`link[data-fx-css="\${href}"]\`)) {
+  const link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.href = href;
+  link.dataset.fxCss = href;
+  document.head.appendChild(link);
+}
+`;
+function createComponentStyles(compile) {
+  let api;
+  let server;
+  let root = process.cwd();
+  let library;
+  const emitted = /* @__PURE__ */ new Map();
+  const fileOf = (id) => existsSync(id) ? id : join(root, id);
+  const cache = /* @__PURE__ */ new Map();
+  const resolveReference = async (ref, importer, ctx, seen, modules) => {
+    const resolved = await ctx.resolve?.(ref.source, importer);
+    if (!resolved) return null;
+    const file = resolved.id.split("?")[0];
+    if (seen.has(file)) return null;
+    let code;
+    try {
+      code = readFileSync(fileOf(file), "utf8");
+    } catch {
+      return null;
+    }
+    const styles = api.styles(file);
+    let result = compile(code, file, styles);
+    if (result?.styleReferences?.length) {
+      const imported = await resolveAll(result.styleReferences, file, ctx, /* @__PURE__ */ new Set([...seen, file]), modules);
+      result = compile(code, file, { ...styles, imported, importedModules: modules });
+    }
+    const literal = result?.styleLiterals?.find((l) => l.name === ref.name);
+    if (!literal) return null;
+    const nodes = literal.nodes ?? styles.process(literal.css, file);
+    const named = firstLoc(nodes);
+    if (named) modules.set(named, { id: file, code });
+    return nodes;
+  };
+  const resolveAll = async (refs, importer, ctx, seen, modules) => {
+    const imported = /* @__PURE__ */ new Map();
+    for (const ref of refs) {
+      const nodes = await resolveReference(ref, importer, ctx, seen, modules);
+      if (nodes) imported.set(`${ref.source}#${ref.name}`, nodes);
+    }
+    return imported;
+  };
+  const run = async (code, id, ctx) => {
+    const file = fileOf(id);
+    const styles = api.styles(file);
+    let result = compile(code, file, styles);
+    if (result?.styleReferences?.length) {
+      const modules = /* @__PURE__ */ new Map();
+      const imported = await resolveAll(result.styleReferences, id, ctx, /* @__PURE__ */ new Set([file]), modules);
+      result = compile(code, file, { ...styles, imported, importedModules: modules });
+    }
+    const css = (result?.styles ?? []).map((s) => s.css);
+    const maps = (result?.styles ?? []).map((s) => s.map ?? null);
+    const literals = new Map((result?.styleLiterals ?? []).map((l) => [l.name, l.css]));
+    const before = cache.get(file);
+    cache.set(file, { source: code, css, maps, literals });
+    if (server && before) {
+      for (let i = 0; i < css.length; i++) {
+        if (before.css[i] === css[i]) continue;
+        const mod = server.moduleGraph.getModuleById(styleId(file, i));
+        if (mod) void server.reloadModule(mod);
+      }
+    }
+    const page = (result?.styles ?? []).flatMap((s, i) => s.shadow ? [] : [i]);
+    if (!result || page.length === 0) return result;
+    if (library) {
+      const name = `${basename(file, extname(file))}.css`;
+      if (existsSync(join(dirname(file), name))) {
+        throw new Error(`[fluixi] ${file} has <style> blocks, and ${name} next to it would be overwritten by their CSS. Rename one of them.`);
+      }
+      const out = join(relative(library, dirname(file)), name);
+      emitted.set(out, page.map((i) => css[i]).join("\n"));
+      emitted.set(`${out}.js`, loader(name));
+      return { ...result, code: `${result.code}
+import ${JSON.stringify(`./${name}`)};` };
+    }
+    const imports = page.map((i) => `
+import ${JSON.stringify(styleId(file, i))};`).join("");
+    return { ...result, code: result.code + imports };
+  };
+  return {
+    /** Looks for @fluixi-css/vite among the plugins; without it component styles stay off. */
+    connect(plugins, projectRoot) {
+      if (projectRoot) root = projectRoot;
+      api = (plugins ?? []).map((p) => p?.api?.fluixiCss).find((a) => Boolean(a));
+      api?.useComponentStyles();
+    },
+    /** Turns on library output, from the directory of a `build.lib` entry. */
+    setLibrary(entryDir) {
+      library = entryDir;
+    },
+    /** A library build's style import: left for the package's consumer to bundle. */
+    isLibraryImport(id, importer) {
+      if (library === void 0 || !importer || !id.startsWith("./") || !id.endsWith(".css")) return false;
+      return emitted.has(join(relative(library, dirname(fileOf(importer))), id));
+    },
+    /** The style files a library build writes, by path under the output directory. */
+    libraryFiles() {
+      return emitted;
+    },
+    get active() {
+      return api !== void 0;
+    },
+    setServer(dev) {
+      server = dev;
+    },
+    isStyle(id) {
+      return STYLE_ID.test(id) || LITERAL_ID.test(id);
+    },
+    /**
+     * A style request as the module id Vite keeps: its owner's absolute path, then the suffix.
+     * One id per block however it was asked for (`/src/card.tsx.fx-0.css` from a page, the
+     * absolute path from the component), or the reload after an edit misses the copy in use.
+     * A css`` value imported from another module names that module relatively, as written.
+     */
+    async resolveId(id, importer, ctx) {
+      const at = id.search(SUFFIX);
+      const owner = id.slice(0, at);
+      if (!owner.startsWith(".")) return fileOf(owner) + id.slice(at);
+      const resolved = importer ? await ctx.resolve?.(owner, importer) : null;
+      return resolved ? resolved.id.split("?")[0] + id.slice(at) : null;
+    },
+    /**
+     * The style modules of a changed file, for the update Vite sends. Their ids do not name the
+     * file (they end in `.css`), so Vite would not find them itself.
+     */
+    hotModules(file, graph) {
+      const entry = cache.get(file);
+      if (!entry) return [];
+      const paths = [
+        ...entry.css.map((_, i) => styleId(file, i)),
+        ...[...entry.literals.keys()].map((name) => styleIds.literal(file, name).replace(/\?inline$/, ""))
+      ];
+      return paths.flatMap((path) => [...graph.getModulesByFile(path) ?? []]);
+    },
+    compile: run,
+    /**
+     * A block's CSS and its map back to the module, compiling the module again when the cache
+     * does not match the file.
+     */
+    async load(id, ctx) {
+      const match = STYLE_ID.exec(id);
+      const literal = LITERAL_ID.exec(id);
+      if (!match && !literal || !api) return null;
+      const file = ownerOf(id);
+      let source;
+      try {
+        source = readFileSync(fileOf(file), "utf8");
+      } catch {
+        return null;
+      }
+      if (cache.get(fileOf(file))?.source !== source) await run(source, file, ctx);
+      const entry = cache.get(fileOf(file));
+      if (literal) {
+        const css = entry?.literals.get(literal[1]);
+        if (css === void 0) throw new Error(`[fluixi] ${literal[1]} in ${file} is not a css\`\` value, so it cannot be a shadow root's styles.`);
+        return { code: css, map: null, moduleType: "css" };
+      }
+      const index = Number(match[1]);
+      return { code: entry?.css[index] ?? "", map: entry?.maps[index] ?? null, moduleType: "css" };
+    }
+  };
+}
+export {
+  createComponentStyles,
+  styleId
+};

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "@fluixi/compiler",
+  "version": "1.0.0-alpha.100",
+  "license": "MIT",
+  "author": "Ibrahima Touré",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fluixi/core.git",
+    "directory": "packages/compiler"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "description": "compiles JSX and html`` templates to direct DOM calls via shared IR; Babel is used as parser only",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./compile": {
+      "types": "./dist/lower/compile-template.d.ts",
+      "import": "./dist/lower/compile-template.mjs",
+      "require": "./dist/lower/compile-template.cjs",
+      "default": "./dist/lower/compile-template.js"
+    },
+    "./babel": {
+      "types": "./dist/frontend/babel/index.d.ts",
+      "import": "./dist/frontend/babel/index.mjs",
+      "require": "./dist/frontend/babel/index.cjs",
+      "default": "./dist/frontend/babel/index.js"
+    },
+    "./integrations": {
+      "types": "./dist/integrations.d.ts",
+      "import": "./dist/integrations.mjs",
+      "require": "./dist/integrations.cjs",
+      "default": "./dist/integrations.js"
+    },
+    "./builtins": {
+      "import": {
+        "types": "./dist/resolve/builtins.d.ts",
+        "default": "./dist/resolve/builtins.mjs"
+      },
+      "require": {
+        "types": "./dist/resolve/builtins.d.cts",
+        "default": "./dist/resolve/builtins.cjs"
+      },
+      "default": "./dist/resolve/builtins.js"
+    },
+    "./transform": {
+      "import": {
+        "types": "./dist/transform/index.d.ts",
+        "default": "./dist/transform/index.mjs"
+      },
+      "require": {
+        "types": "./dist/transform/index.d.cts",
+        "default": "./dist/transform/index.cjs"
+      },
+      "default": "./dist/transform/index.js"
+    },
+    "./analyze": {
+      "import": {
+        "types": "./dist/analyze/static-graph.d.ts",
+        "default": "./dist/analyze/static-graph.mjs"
+      },
+      "require": {
+        "types": "./dist/analyze/static-graph.d.cts",
+        "default": "./dist/analyze/static-graph.cjs"
+      },
+      "default": "./dist/analyze/static-graph.js"
+    },
+    "./intrinsics": {
+      "types": "./dist/analyze/intrinsics.d.ts",
+      "import": "./dist/analyze/intrinsics.mjs",
+      "require": "./dist/analyze/intrinsics.cjs",
+      "default": "./dist/analyze/intrinsics.js"
+    }
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.5",
+    "@jridgewell/sourcemap-codec": "^1.5.5",
+    "magic-string": "^0.30.21",
+    "@fluixi/template-parser": "^1.0.0-alpha.100"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/generator": "^7.29.1",
+    "@babel/helper-plugin-utils": "^7.27.1",
+    "@babel/plugin-transform-modules-commonjs": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
+    "@bambiste/mix-builder": "^0.4.0",
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__helper-plugin-utils": "^7.10.3",
+    "cross-env": "^7.0.3",
+    "inquirer": "^14.0.2",
+    "jsdom": "^25.0.0",
+    "vitest": "^5.0.3",
+    "@fluixi/dom": "1.0.0-alpha.100",
+    "@fluixi/reactive": "1.0.0-alpha.100"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/generator": "^7.29.1",
+    "@babel/helper-plugin-utils": "^7.27.1",
+    "@babel/preset-typescript": "^7.28.5"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    },
+    "@babel/generator": {
+      "optional": true
+    },
+    "@babel/helper-plugin-utils": {
+      "optional": true
+    },
+    "@babel/preset-typescript": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build:typings": "tsc -p tsconfig.lib.json",
+    "build": "cross-env NODE_ENV=production mix-builder",
+    "dev": "tsc -w -p tsconfig.lib.json",
+    "test": "vitest run"
+  }
+}