lapikit 0.0.0-insiders.1609831

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Nycolaide <https://github.com/Nycolaide>.
+
+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 @@
+# Lapikit

package/bin/helper.js

@@ -0,0 +1,74 @@
+const color = {
+	red: (text) => `\x1b[31m${text}\x1b[0m`,
+	green: (text) => `\x1b[32m${text}\x1b[0m`,
+	yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+	blue: (text) => `\x1b[34m${text}\x1b[0m`,
+	purple: (text) => `\x1b[35m${text}\x1b[0m`,
+	cyan: (text) => `\x1b[36m${text}\x1b[0m`
+};
+
+const variant = {
+	bold: (text) => `\x1b[1m${text}\x1b[0m`,
+	underline: (text) => `\x1b[4m${text}\x1b[0m`,
+	inverse: (text) => `\x1b[7m${text}\x1b[0m`
+};
+
+const bold = {
+	red: (text) => `\x1b[1m\x1b[31m${text}\x1b[0m`,
+	green: (text) => `\x1b[1m\x1b[32m${text}\x1b[0m`,
+	yellow: (text) => `\x1b[1m\x1b[33m${text}\x1b[0m`,
+	blue: (text) => `\x1b[1m\x1b[34m${text}\x1b[0m`,
+	purple: (text) => `\x1b[1m\x1b[35m${text}\x1b[0m`,
+	cyan: (text) => `\x1b[1m\x1b[36m${text}\x1b[0m`
+};
+
+const inverse = {
+	red: (text) => `\x1b[7m\x1b[31m${text}\x1b[0m`,
+	green: (text) => `\x1b[7m\x1b[32m${text}\x1b[0m`,
+	yellow: (text) => `\x1b[7m\x1b[33m${text}\x1b[0m`,
+	blue: (text) => `\x1b[7m\x1b[34m${text}\x1b[0m`,
+	purple: (text) => `\x1b[7m\x1b[35m${text}\x1b[0m`,
+	cyan: (text) => `\x1b[7m\x1b[36m${text}\x1b[0m`
+};
+
+const underline = {
+	red: (text) => `\x1b[4m\x1b[31m${text}\x1b[0m`,
+	green: (text) => `\x1b[4m\x1b[32m${text}\x1b[0m`,
+	yellow: (text) => `\x1b[4m\x1b[33m${text}\x1b[0m`,
+	blue: (text) => `\x1b[4m\x1b[34m${text}\x1b[0m`,
+	purple: (text) => `\x1b[4m\x1b[35m${text}\x1b[0m`,
+	cyan: (text) => `\x1b[4m\x1b[36m${text}\x1b[0m`
+};
+
+export const ansi = {
+	color,
+	variant,
+	bold,
+	inverse,
+	underline
+};
+
+export const terminal = (type = 'info', msg) => {
+	const name = ansi.color.cyan('lapikit');
+
+	if (type === 'error') console.error(name, ansi.bold.red('[error]'), msg);
+	else if (type === 'warn') console.warn(name, ansi.bold.yellow('[warn]'), msg);
+	else if (type === 'success') console.warn(name, ansi.bold.green('[success]'), msg);
+	else if (type === 'none') console.log(msg);
+	else console.log(name, ansi.bold.blue('[info]'), msg);
+};
+
+export function getCssPathFromArgs() {
+	const args = process.argv.slice(2);
+	return args[1] || 'src/app.css';
+}
+
+export async function envTypescript() {
+	const directory = process.cwd();
+	try {
+		await fs.readFile(path.resolve(directory, 'tsconfig.json'), 'utf-8');
+		return true;
+	} catch {
+		return false;
+	}
+}

package/bin/lapikit.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { promises as fs } from 'fs';
+import path from 'path';
+import { ansi, terminal, envTypescript } from './helper.js';
+import { preset } from './modules/preset.js';
+import { adapterCSSConfig, adapterViteConfig } from './modules/adapter.js';
+
+const [, , command] = process.argv;
+const typescriptEnabled = envTypescript();
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+	terminal(
+		'info',
+		`usage: ${ansi.color.yellow('npx lapikit init {cssPath}')}\n\n ${ansi.variant.bold('options:')}\n
+        - {cssPath}: (${ansi.color.cyan('src/app.css')}) customize path on your origin css file.\n\n`
+	);
+	process.exit(0);
+} else if (command === 'init') {
+	console.log('  _                 _ _    _ _   ');
+	console.log(' | |               (_) |  (_) |  ');
+	console.log(' | |     __ _ _ __  _| | ___| |_ ');
+	console.log(" | |    / _` | '_ \\| | |/ / | __|");
+	console.log(' | |___| (_| | |_) | |   <| | |_ ');
+	console.log(' |______\\__,_| .__/|_|_|\\_\\_|\\__|');
+	console.log('             | |                 ');
+	console.log('             |_|                 \n');
+
+	terminal('none', `${ansi.bold.blue('LAPIKIT')} - Component Library for Svelte\n\n`);
+
+	const configPath = path.resolve(process.cwd(), 'lapikit.config.js');
+	try {
+		await fs.writeFile(configPath, preset.trim() + '\n', 'utf8');
+		terminal('success', `has create lapikit.config.js on your project.`);
+	} catch (error) {
+		terminal('error', `failed to create configuration file:\n\n ${error}`);
+		terminal(
+			'warn',
+			`you can create lapikit.config.js manually, please visite https://localhost:3000/docs for more information`
+		);
+	}
+
+	await adapterViteConfig(typescriptEnabled);
+	await adapterCSSConfig();
+
+	terminal(
+		'info',
+		`${ansi.bold.blue('Thank to use lapikit, discover all posibility with lapikit on https://localhost:3000/docs')}\n\n`
+	);
+
+	console.log('Github: https://github.com/nycolaide/lapikit');
+	console.log('Support the developement: https://buymeacoffee.com/nycolaide');
+} else {
+	terminal('error', `Command not recognized. Try 'npx lapikit -h'`);
+}

package/bin/modules/adapter.js

@@ -0,0 +1,52 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getCssPathFromArgs, terminal } from '../helper.js';
+
+const importLapikitVite = `import { lapikit } from 'lapikit/vite';`;
+const importLapikitCss = `@import 'lapikit/css';`;
+
+export async function adapterViteConfig(typescript) {
+	const viteConfigPath = path.resolve(process.cwd(), `vite.config.${typescript ? 'ts' : 'js'}`);
+	try {
+		let viteConfig = await fs.readFile(viteConfigPath, 'utf8');
+
+		if (!viteConfig.includes(`${importLapikitVite}`))
+			viteConfig = `${importLapikitVite}\n` + viteConfig;
+
+		const pluginsRegex = /plugins:\s*\[([^\]]*)\]/;
+		const match = viteConfig.match(pluginsRegex);
+
+		if (match && !match[1].includes('lapikit()')) {
+			const updatedPlugins = match[1].trim() ? `${match[1].trim()}, lapikit()` : `lapikit()`;
+
+			viteConfig = viteConfig.replace(pluginsRegex, `plugins: [${updatedPlugins}]`);
+		}
+
+		await fs.writeFile(viteConfigPath, viteConfig, 'utf8');
+
+		terminal('success', 'lapikit() has added on vite.config.(js|ts) successfully');
+	} catch (error) {
+		terminal(
+			'error',
+			`lapikit() encountered a problem while editing vite.config.(js|ts):\n ${error}.\n\n`
+		);
+	}
+}
+
+export async function adapterCSSConfig() {
+	const cssPath = getCssPathFromArgs();
+	const resolvedPath = path.resolve(process.cwd(), cssPath);
+	try {
+		await fs.access(resolvedPath);
+		let appCssContent = await fs.readFile(resolvedPath, 'utf8');
+		appCssContent = `${importLapikitCss}\n\n` + appCssContent;
+		await fs.writeFile(resolvedPath, appCssContent, 'utf8');
+
+		terminal('success', `lapikit/css has added on ${cssPath}.`);
+	} catch (error) {
+		terminal(
+			'error',
+			`lapikit/css encountered a problem while editing ${cssPath}:\n  ${error.message}.\n\n`
+		);
+	}
+}

package/bin/modules/preset.js

@@ -0,0 +1,11 @@
+export const preset = `
+/** @type {import('lapikit').Config} */
+export default {
+	theme: {
+		colorScheme: 'light',
+		colors: {
+			svelte: '#ff3e00'
+		}
+	}
+};
+`;

package/dist/app.d.ts

@@ -0,0 +1,13 @@
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+declare global {
+	namespace App {
+		// interface Error {}
+		// interface Locals {}
+		// interface PageData {}
+		// interface PageState {}
+		// interface Platform {}
+	}
+}
+
+export {};

package/dist/app.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div>%sveltekit.body%</div>
+	</body>
+</html>

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare function helloWorld(): void;

package/dist/index.js

@@ -0,0 +1,4 @@
+// Reexport your entry components here
+export function helloWorld() {
+    console.log('Hello world, this is lapikit!');
+}

package/dist/internal/ansi.d.ts

@@ -0,0 +1,40 @@
+export declare const ansi: {
+    color: {
+        red: (text: string) => string;
+        green: (text: string) => string;
+        yellow: (text: string) => string;
+        blue: (text: string) => string;
+        purple: (text: string) => string;
+        cyan: (text: string) => string;
+    };
+    variant: {
+        bold: (text: string) => string;
+        underline: (text: string) => string;
+        inverse: (text: string) => string;
+    };
+    bold: {
+        red: (text: string) => string;
+        green: (text: string) => string;
+        yellow: (text: string) => string;
+        blue: (text: string) => string;
+        purple: (text: string) => string;
+        cyan: (text: string) => string;
+    };
+    inverse: {
+        red: (text: string) => string;
+        green: (text: string) => string;
+        yellow: (text: string) => string;
+        blue: (text: string) => string;
+        purple: (text: string) => string;
+        cyan: (text: string) => string;
+    };
+    underline: {
+        red: (text: string) => string;
+        green: (text: string) => string;
+        yellow: (text: string) => string;
+        blue: (text: string) => string;
+        purple: (text: string) => string;
+        cyan: (text: string) => string;
+    };
+};
+export type Ansi = typeof ansi;

package/dist/internal/ansi.js

@@ -0,0 +1,44 @@
+const color = {
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`
+};
+const variant = {
+    bold: (text) => `\x1b[1m${text}\x1b[0m`,
+    underline: (text) => `\x1b[4m${text}\x1b[0m`,
+    inverse: (text) => `\x1b[7m${text}\x1b[0m`
+};
+const bold = {
+    red: (text) => `\x1b[1m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[1m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[1m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[1m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[1m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[1m\x1b[36m${text}\x1b[0m`
+};
+const inverse = {
+    red: (text) => `\x1b[7m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[7m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[7m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[7m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[7m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[7m\x1b[36m${text}\x1b[0m`
+};
+const underline = {
+    red: (text) => `\x1b[4m\x1b[31m${text}\x1b[0m`,
+    green: (text) => `\x1b[4m\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[4m\x1b[33m${text}\x1b[0m`,
+    blue: (text) => `\x1b[4m\x1b[34m${text}\x1b[0m`,
+    purple: (text) => `\x1b[4m\x1b[35m${text}\x1b[0m`,
+    cyan: (text) => `\x1b[4m\x1b[36m${text}\x1b[0m`
+};
+export const ansi = {
+    color,
+    variant,
+    bold,
+    inverse,
+    underline
+};

package/dist/internal/colors.d.ts

@@ -0,0 +1 @@
+export declare const parseColor: (input: string) => string;

package/dist/internal/colors.js

@@ -0,0 +1,50 @@
+import { x11Colors } from '../utils/x11.js';
+export const parseColor = (input) => {
+    input = input.trim();
+    if (input.startsWith('#')) {
+        const rgb = hexToRgb(input);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    if (input.startsWith('rgb')) {
+        const parts = input
+            .replace(/rgba?|\(|\)|\s+/g, '')
+            .split(',')
+            .map(Number);
+        return rgbToOklch(parts[0], parts[1], parts[2]);
+    }
+    if (input.startsWith('oklch('))
+        return input;
+    if (x11Colors[input]) {
+        const hex = x11Colors[input];
+        const rgb = hexToRgb(hex);
+        return rgbToOklch(rgb.r, rgb.g, rgb.b);
+    }
+    return input;
+};
+const hexToRgb = (hex) => {
+    const clean = hex.replace('#', '');
+    const bigint = parseInt(clean, 16);
+    return {
+        r: (bigint >> 16) & 255,
+        g: (bigint >> 8) & 255,
+        b: bigint & 255
+    };
+};
+const srgbToLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+const rgbToOklch = (r, g, b) => {
+    r = srgbToLinear(r / 255);
+    g = srgbToLinear(g / 255);
+    b = srgbToLinear(b / 255);
+    const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    const l_ = Math.cbrt(l);
+    const m_ = Math.cbrt(m);
+    const s_ = Math.cbrt(s);
+    const L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_;
+    const a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_;
+    const b_ = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_;
+    const C = Math.sqrt(a * a + b_ * b_);
+    const h = (Math.atan2(b_, a) * 180) / Math.PI;
+    return `oklch(${(L * 100).toFixed(3)}% ${C.toFixed(4)} ${((h + 360) % 360).toFixed(2)})`;
+};

package/dist/internal/index.d.ts

@@ -0,0 +1,2 @@
+export * from './terminal.js';
+export * from './ansi.js';

package/dist/internal/index.js

@@ -0,0 +1,2 @@
+export * from './terminal.js';
+export * from './ansi.js';

package/dist/internal/minify.d.ts

@@ -0,0 +1 @@
+export declare const minify: (css: string) => string;

package/dist/internal/minify.js

@@ -0,0 +1,10 @@
+export const minify = (css) => {
+    const minified = css
+        .replace(/\s+/g, ' ')
+        .replace(/\/\*.*?\*\//g, '')
+        .replace(/;\s*}/g, '}')
+        .replace(/:\s+/g, ':')
+        .replace(/\s*([{};:])\s*/g, '$1')
+        .trim();
+    return minified;
+};

package/dist/internal/terminal.d.ts

@@ -0,0 +1 @@
+export declare const terminal: (type: "info" | "error" | "warn" | "success" | undefined, msg: string) => void;

package/dist/internal/terminal.js

@@ -0,0 +1,12 @@
+import { ansi } from './ansi.js';
+export const terminal = (type = 'info', msg) => {
+    const name = ansi.color.cyan('lapikit');
+    if (type === 'error')
+        console.error(name, ansi.bold.red('[error]'), msg);
+    else if (type === 'warn')
+        console.warn(name, ansi.bold.yellow('[warn]'), msg);
+    else if (type === 'success')
+        console.warn(name, ansi.bold.green('[success]'), msg);
+    else
+        console.log(name, ansi.bold.blue('[info]'), msg);
+};

package/dist/internal/types.d.ts

@@ -0,0 +1,44 @@
+export type FontFamily = {
+    [key: string]: string | string[];
+};
+export type Colors = {
+    [key: string]: {
+        light: string;
+        dark: string;
+    } | string;
+};
+export type Thresholds = {
+    [key: string]: number | string;
+};
+export type Radius = {
+    [key: string]: number | string;
+};
+export interface Lapikit {
+    options: {
+        normalize: boolean;
+        minify: boolean;
+    };
+    theme: {
+        colorScheme: string;
+        colors: Colors;
+    };
+    breakpoints: {
+        mobileBreakpoint: string;
+        tabletBreakpoint: string;
+        laptopBreakpoint: string;
+        thresholds: Thresholds;
+    };
+    styles: {
+        spacing: string;
+        corner: {
+            active: boolean;
+            radius: Radius;
+        };
+        font: FontFamily;
+    };
+}
+type DeepOptional<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepOptional<U>[] : T[P] extends object ? DeepOptional<T[P]> : T[P];
+};
+export type LapikitConfig = DeepOptional<Lapikit>;
+export {};

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/modules/config.d.ts

@@ -0,0 +1,2 @@
+import type { LapikitConfig } from '../../internal/types.js';
+export declare const parseConfig: (props?: LapikitConfig) => import("../../internal/types.js").Lapikit;

package/dist/plugin/modules/config.js

@@ -0,0 +1,54 @@
+import { config } from '../../preset.js';
+export const parseConfig = (props) => {
+    if (!props)
+        return config;
+    const newConfig = { ...config };
+    if (props?.options) {
+        if (props.options.normalize !== undefined)
+            newConfig.options.normalize = props.options.normalize;
+        if (props.options.minify !== undefined)
+            newConfig.options.minify = props.options.minify;
+    }
+    if (props?.theme) {
+        if (props.theme.colorScheme !== undefined)
+            newConfig.theme.colorScheme = props.theme.colorScheme;
+        if (props.theme.colors) {
+            newConfig.theme.colors = {
+                ...newConfig.theme.colors,
+                ...props.theme.colors
+            };
+        }
+    }
+    if (props?.breakpoints) {
+        if (props.breakpoints.mobileBreakpoint !== undefined)
+            newConfig.breakpoints.mobileBreakpoint = props.breakpoints.mobileBreakpoint;
+        if (props.breakpoints.tabletBreakpoint !== undefined)
+            newConfig.breakpoints.tabletBreakpoint = props.breakpoints.tabletBreakpoint;
+        if (props.breakpoints.laptopBreakpoint !== undefined)
+            newConfig.breakpoints.laptopBreakpoint = props.breakpoints.laptopBreakpoint;
+        if (props.breakpoints.thresholds)
+            newConfig.breakpoints.thresholds = {
+                ...newConfig.breakpoints.thresholds,
+                ...props.breakpoints.thresholds
+            };
+    }
+    if (props?.styles) {
+        if (props.styles.spacing !== undefined)
+            newConfig.styles.spacing = props.styles.spacing;
+        if (props.styles.corner !== undefined) {
+            if (props.styles.corner.active !== undefined)
+                newConfig.styles.corner.active = props.styles.corner.active;
+            if (props.styles.corner.radius)
+                newConfig.styles.corner.radius = {
+                    ...newConfig.styles.corner.radius,
+                    ...props.styles.corner.radius
+                };
+        }
+        if (props.styles.font)
+            newConfig.styles.font = {
+                ...newConfig.styles.font,
+                ...props.styles.font
+            };
+    }
+    return newConfig;
+};

package/dist/plugin/modules/importer.d.ts

@@ -0,0 +1 @@
+export declare const importer: () => Promise<any>;

package/dist/plugin/modules/importer.js

@@ -0,0 +1,15 @@
+import path from 'path';
+import fs from 'fs';
+import { terminal, ansi } from '../../internal/index.js';
+const app = process.cwd();
+const pathConfig = path.resolve(app, 'lapikit.config.js');
+export const importer = async () => {
+    if (!fs.existsSync(pathConfig)) {
+        terminal('error', `config file not found\n ${ansi.color.yellow('Could not find lapikit.config.js. See https://localhost/docs/kit/vite to learn more about the configuration file.')}\n\n${ansi.color.blue('for initializing a new lapikit config, run:')}\n        ${ansi.variant.bold('npx lapikit init')}    ${ansi.bold.yellow('(preview)')}\n\n`);
+        process.exit(1);
+    }
+    const timestamp = Date.now();
+    const fileUrl = `file://${pathConfig}?t=${timestamp}`;
+    const content = await import(fileUrl);
+    return content.default;
+};

package/dist/plugin/vitejs.d.ts

@@ -0,0 +1,6 @@
+import type { ViteDevServer } from 'vite';
+export declare function lapikit(): Promise<{
+    name: string;
+    configResolved(): Promise<void>;
+    configureServer(server: ViteDevServer): Promise<void>;
+}>;

package/dist/plugin/vitejs.js

@@ -0,0 +1,26 @@
+import { importer } from './modules/importer.js';
+import { processCSS } from '../style/css.js';
+import { parseConfig } from './modules/config.js';
+import { terminal } from '../internal/terminal.js';
+export async function lapikit() {
+    return {
+        name: 'lapikit/vite.js',
+        async configResolved() {
+            const config = await importer();
+            const result = await parseConfig(config);
+            await processCSS(result);
+            terminal('info', 'lapikit is up!');
+        },
+        async configureServer(server) {
+            server.watcher.add('./lapikit.config.js');
+            server.watcher.on('change', async (filePath) => {
+                if (String(filePath).includes('lapikit.config.js')) {
+                    const config = await importer();
+                    const result = await parseConfig(config);
+                    await processCSS(result);
+                    terminal('info', 'lapikit config reloaded');
+                }
+            });
+        }
+    };
+}

package/dist/preset.d.ts

@@ -0,0 +1,2 @@
+import type { Lapikit } from './internal/types.js';
+export declare const config: Lapikit;