@jesscss/plugin-less-compat 2.0.0-alpha.1 → 2.0.0-alpha.10

package/lib/index.js

@@ -1,10 +1,333 @@
+import { AbstractPlugin } from "@jesscss/core";
+import { HEX, defineFunction, emitValue, groupItems, makeColorRgb, makeDimension, makeKeyword, makeList, makeQuoted, sniffLiteral } from "@jesscss/core/value";
+//#region src/less-api-bridge.ts
+const isThenable = (value) => value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+function isLoadedPluginModule(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("functions" in value) || value.functions === void 0) return true;
+	return typeof value.functions === "object" && value.functions !== null && Object.values(value.functions).every((fn) => typeof fn === "function");
+}
+const nativeNil = () => {
+	const nil = {
+		type: "Nil",
+		value: "",
+		eval: () => nil
+	};
+	return nil;
+};
+var LessDimension = class {
+	type = "Dimension";
+	constructor(value, unit = "") {
+		this.value = value;
+		this.unit = unit;
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+var LessQuoted = class {
+	type = "Quoted";
+	constructor(quote, value, escaped = false) {
+		this.quote = quote;
+		this.value = value;
+		this.escaped = escaped;
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+var LessColor = class {
+	type = "Color";
+	value;
+	constructor(rgb, alpha = 1) {
+		this.rgb = rgb;
+		this.alpha = alpha;
+		this.value = typeof rgb === "string" ? rgb.startsWith("#") ? rgb : `#${rgb}` : `rgb(${rgb.join(", ")})`;
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+var LessAnonymous = class {
+	type = "Anonymous";
+	value;
+	constructor(value) {
+		this.value = String(value);
+	}
+	valueOf() {
+		return this.value;
+	}
+};
+var LazyExpression = class {
+	type = "Expression";
+	#value;
+	constructor(source) {
+		this.source = source;
+	}
+	get value() {
+		return this.#value ??= this.source.map(toNativeLessValue);
+	}
+	valueOf() {
+		return emitValue(this.source);
+	}
+};
+var LazyValueList = class {
+	type = "Value";
+	#value;
+	constructor(source) {
+		this.source = source;
+	}
+	get value() {
+		return this.#value ??= this.source.value.map(toNativeLessValue);
+	}
+	get separator() {
+		return this.source.sep;
+	}
+	valueOf() {
+		return this.source.bytes;
+	}
+};
+var LazyDetachedDeclaration = class {
+	type = "Declaration";
+	#value;
+	#hasValue = false;
+	constructor(name, source) {
+		this.name = name;
+		this.source = source;
+	}
+	get value() {
+		if (!this.#hasValue) {
+			this.#value = toNativeLessValue(this.source);
+			this.#hasValue = true;
+		}
+		return this.#value;
+	}
+	eval() {
+		return this;
+	}
+};
+var LazyDetachedRuleset = class {
+	type = "Mixin";
+	name = nativeNil();
+	args = nativeNil();
+	#rules;
+	constructor(source) {
+		this.source = source;
+	}
+	get ruleset() {
+		return { rules: this.rules };
+	}
+	get rules() {
+		return this.#rules ??= this.source.rules.map((rule) => new LazyDetachedDeclaration(rule.name, rule.value));
+	}
+	eval() {
+		return this;
+	}
+};
+function isRawSequence(value) {
+	return Array.isArray(value);
+}
+function isPluginDetached(value) {
+	return !isRawSequence(value) && value.type === "DetachedRuleset";
+}
+function toNativeLessValue(value) {
+	if (isRawSequence(value)) return new LazyExpression(value);
+	if (isPluginDetached(value)) return new LazyDetachedRuleset(value);
+	switch (value.type) {
+		case "Dimension": return new LessDimension(value.number, value.unit);
+		case "Quoted": return new LessQuoted(value.quote, value.value, value.escaped);
+		case "Color": return {
+			type: "Color",
+			rgb: value.rgb,
+			alpha: value.alpha,
+			valueOf: () => value.bytes
+		};
+		case "List": return value.sep === "," || value.sep === "/" ? new LazyValueList(value) : new LessAnonymous(value.bytes);
+		default: return new LessAnonymous(value.bytes);
+	}
+}
+function isNativeValue(value) {
+	return value !== null && typeof value === "object" && "bytes" in value && typeof value.bytes === "string";
+}
+function fromNativeLessValue(value) {
+	if (isNativeValue(value)) return value;
+	if (typeof value === "number") return makeDimension(value);
+	if (typeof value === "string") return sniffLiteral(value);
+	if (value && typeof value === "object") {
+		const candidate = value;
+		if ((candidate.type === "Dimension" || candidate.type === "Num") && typeof candidate.value === "number") return makeDimension(candidate.value, typeof candidate.unit === "string" ? candidate.unit : "");
+		if (candidate.type === "Quoted" && typeof candidate.value === "string") return makeQuoted(candidate.value, candidate.quote === "'" ? "'" : "\"", candidate.escaped === true);
+		if (candidate.type === "Color") {
+			if (Array.isArray(candidate.rgb)) {
+				const [r = 0, g = 0, b = 0] = candidate.rgb.map(Number);
+				const alpha = typeof candidate.alpha === "number" ? candidate.alpha : 1;
+				return makeColorRgb([
+					r,
+					g,
+					b
+				], alpha, HEX);
+			}
+			if (typeof candidate.rgb === "string") return sniffLiteral(candidate.rgb.startsWith("#") ? candidate.rgb : `#${candidate.rgb}`);
+		}
+		if (candidate.type === "Expression" && Array.isArray(candidate.value)) return candidate.value.map(fromNativeLessValue);
+		if (candidate.type === "Value" && Array.isArray(candidate.value)) {
+			const separator = candidate.separator === "/" ? "/" : ",";
+			return makeList(candidate.value.map((item) => fromNativeLessValue(item)), separator);
+		}
+		if (typeof candidate.value === "string") return sniffLiteral(candidate.value);
+		if (typeof candidate.valueOf === "function") return sniffLiteral(String(candidate.valueOf()));
+	}
+	return makeKeyword(value == null ? "" : String(value));
+}
+var LessApiBridge = class {
+	less;
+	registry;
+	globalFns;
+	#fns = [];
+	#nativeFns = /* @__PURE__ */ new WeakMap();
+	#contextualFns = /* @__PURE__ */ new WeakMap();
+	#registered = /* @__PURE__ */ new Map();
+	constructor(plugins = []) {
+		this.registry = {
+			add: (name, fn) => {
+				this.addFunction(name, fn);
+			},
+			addMultiple: (functions) => {
+				for (const [name, fn] of Object.entries(functions)) this.registry.add(name, fn);
+			},
+			get: (name) => this.#registered.get(name.toLowerCase())
+		};
+		this.less = {
+			functions: { functionRegistry: this.registry },
+			tree: {
+				Dimension: LessDimension,
+				Quoted: LessQuoted,
+				Color: LessColor,
+				Anonymous: LessAnonymous
+			}
+		};
+		for (const plugin of plugins) plugin.install?.(this.less, void 0, this.registry);
+		this.globalFns = this.#fns;
+	}
+	addFunction(name, fn) {
+		const lowerName = name.toLowerCase();
+		this.#registered.set(lowerName, fn);
+		const adapted = defineFunction(lowerName, {
+			variadic: true,
+			params: [],
+			body: (value) => this.invokeNativeFunction(fn, groupItems(value))
+		});
+		this.#nativeFns.set(adapted, fn);
+		this.#fns.push(adapted);
+		return adapted;
+	}
+	addContextualFunction(name, fn) {
+		const adapted = defineFunction(name.toLowerCase(), {
+			variadic: true,
+			params: [],
+			body: () => {
+				throw new Error(`Less @plugin function "${name}" needs live plugin invocation capabilities; it cannot run through plain function dispatch.`);
+			}
+		});
+		this.#contextualFns.set(adapted, fn);
+		this.#fns.push(adapted);
+		return adapted;
+	}
+	invokeNativeFunction(fn, args) {
+		const result = fn(...args.map(toNativeLessValue));
+		return isThenable(result) ? Promise.resolve(result).then(fromNativeLessValue) : fromNativeLessValue(result);
+	}
+	invokeContextualFunction(fn, args, ctx) {
+		const result = fn(args.map(toNativeLessValue), {
+			lookupVariable: (name) => {
+				const hit = ctx.lookupVariable(name);
+				return hit === null ? null : {
+					value: toNativeLessValue(hit.value),
+					important: hit.important
+				};
+			},
+			callFunction: (name, callArgs) => {
+				const answer = ctx.callFunction(name, callArgs.map(fromNativeLessValue));
+				return answer === void 0 ? void 0 : toNativeLessValue(answer);
+			},
+			currentFileInfo: ctx.currentFileInfo,
+			log: (record) => ctx.log(record),
+			markImportant: () => ctx.markImportant()
+		});
+		return isThenable(result) ? Promise.resolve(result).then(fromNativeLessValue) : fromNativeLessValue(result);
+	}
+	invokeRawFunction(fn, args, ctx) {
+		const contextual = this.#contextualFns.get(fn);
+		if (contextual) return this.invokeContextualFunction(contextual, args, ctx);
+		const native = this.#nativeFns.get(fn);
+		return native ? this.invokeNativeFunction(native, args) : void 0;
+	}
+	createPluginHost(optionsOrLoader) {
+		const loadPluginModule = typeof optionsOrLoader === "function" ? optionsOrLoader : optionsOrLoader?.loadPluginModule;
+		const host = {
+			...this.globalFns.length === 0 ? {} : { globalFns: this.globalFns },
+			invokeRawFunction: (fn, args, ctx) => this.invokeRawFunction(fn, args, ctx)
+		};
+		if (loadPluginModule) host.loadPlugin = (request) => {
+			const loaded = loadPluginModule(request);
+			const addLoaded = (module) => {
+				const functions = isLoadedPluginModule(module) ? module.functions : void 0;
+				if (!functions) return [];
+				return Object.entries(functions).map(([name, fn]) => this.addContextualFunction(name, fn));
+			};
+			return isThenable(loaded) ? Promise.resolve(loaded).then(addLoaded) : addLoaded(loaded);
+		};
+		return host;
+	}
+};
+//#endregion
+//#region src/plugin.ts
 /**
- * @jesscss/plugin-less-compat
- *
- * Less.js compatibility layer for Jess.
- * Enables Less.js plugins and visitors to work with Jess AST.
- */
-export { LessCompatPlugin, default as lessCompatPlugin } from './plugin.js';
-export * from './transform/index.js';
-export { isLessPlugin, isJessPlugin, filterPlugins } from './plugin-utils.js';
-//# sourceMappingURL=index.js.map
+* Transitional package boundary for applications that previously installed the
+* Less compatibility plugin. It contributes only native AST-v2 `Fn` values.
+*
+* Less 4 visitor hooks, `functionRegistry` callbacks, and `@plugin` script
+* execution were legacy tree-runtime APIs. They are intentionally unsupported
+* on the public AST-v2 compiler route: preserving them would require a second
+* evaluator and Node-to-Less/ Less-to-Node conversion bridge.
+*/
+var LessCompatPlugin = class extends AbstractPlugin {
+	name = "less-compat";
+	bridges = /* @__PURE__ */ new WeakMap();
+	constructor(opts = {}) {
+		super();
+		this.opts = opts;
+	}
+	setContext(context) {
+		let bridge = this.bridges.get(context);
+		if (!bridge) {
+			bridge = new LessApiBridge(this.opts.plugins ?? []);
+			this.bridges.set(context, bridge);
+		}
+		const bridgeHost = bridge.createPluginHost(({ specifier, options }) => context.getPluginModule(specifier, options));
+		const functions = this.opts.functions;
+		const host = context.pluginHost;
+		const globalFns = [
+			...host?.globalFns ?? [],
+			...bridgeHost.globalFns ?? [],
+			...functions ?? []
+		];
+		context.pluginHost = {
+			...host,
+			...globalFns.length === 0 ? {} : { globalFns },
+			loadPlugin: bridgeHost.loadPlugin || host?.loadPlugin ? (request) => {
+				const baseLoaded = host?.loadPlugin?.(request);
+				const bridgeLoaded = bridgeHost.loadPlugin?.(request);
+				const merge = (baseFns, bridgeFns) => [...baseFns ?? [], ...bridgeFns ?? []];
+				const baseThenable = baseLoaded && typeof baseLoaded === "object" && "then" in baseLoaded;
+				const bridgeThenable = bridgeLoaded && typeof bridgeLoaded === "object" && "then" in bridgeLoaded;
+				if (baseThenable || bridgeThenable) return Promise.all([baseLoaded ?? [], bridgeLoaded ?? []]).then(([baseFns, bridgeFns]) => merge(baseFns, bridgeFns));
+				return merge(baseLoaded, bridgeLoaded);
+			} : void 0,
+			invokeRawFunction: (fn, args, ctx) => bridgeHost.invokeRawFunction?.(fn, args, ctx) ?? host?.invokeRawFunction?.(fn, args, ctx)
+		};
+	}
+};
+const lessCompatPlugin = (opts) => new LessCompatPlugin(opts);
+//#endregion
+export { LessApiBridge, LessCompatPlugin, lessCompatPlugin as default, lessCompatPlugin, fromNativeLessValue, toNativeLessValue };

package/lib/less-api-bridge.d.ts

@@ -0,0 +1,85 @@
+import type { MaybePromise } from '@jesscss/awaitable-pipe';
+import { type Fn, type PluginCallCtx, type PluginHost, type PluginRawArgument, type ValueGroup } from '@jesscss/core/value';
+export type NativeLessFunction = (...args: unknown[]) => unknown;
+export type ContextualPluginFunction = (args: readonly unknown[], capabilities: {
+    lookupVariable?(name: string): {
+        value: unknown;
+        important?: boolean;
+    } | null;
+    callFunction?(name: string, args: unknown[]): unknown;
+    currentFileInfo?: {
+        filename: string;
+        entryPath: string;
+    };
+    log?(record: {
+        level: string;
+        message: string;
+    }): void;
+    markImportant?(): void;
+}) => unknown | Promise<unknown>;
+export type NativeLessPlugin = {
+    readonly name?: string;
+    readonly opts?: unknown;
+    install?(less: NativeLessApi, manager: undefined, functions: NativeLessFunctionRegistry): void;
+};
+export interface NativeLessFunctionRegistry {
+    add(name: string, fn: NativeLessFunction): void;
+    addMultiple(functions: Record<string, NativeLessFunction>): void;
+    get(name: string): NativeLessFunction | undefined;
+}
+export interface NativeLessApi {
+    functions: {
+        functionRegistry: NativeLessFunctionRegistry;
+    };
+    tree: {
+        Dimension: new (value: number, unit?: string) => NativeLessDimension;
+        Quoted: new (quote: string, value: string, escaped?: boolean) => NativeLessQuoted;
+        Color: new (rgb: string | readonly [number, number, number], alpha?: number) => NativeLessColor;
+        Anonymous: new (value: unknown) => NativeLessAnonymous;
+    };
+}
+export interface NativeLessDimension {
+    readonly type: 'Dimension';
+    readonly value: number;
+    readonly unit: string;
+    valueOf(): number;
+}
+export interface NativeLessQuoted {
+    readonly type: 'Quoted';
+    readonly quote: string;
+    readonly value: string;
+    readonly escaped: boolean;
+    valueOf(): string;
+}
+export interface NativeLessColor {
+    readonly type: 'Color';
+    readonly rgb: string | readonly [number, number, number];
+    readonly alpha: number;
+    readonly value: string;
+    valueOf(): string;
+}
+export interface NativeLessAnonymous {
+    readonly type: 'Anonymous';
+    readonly value: string;
+    valueOf(): string;
+}
+type PluginModuleLoader = (request: Parameters<NonNullable<PluginHost['loadPlugin']>>[0]) => MaybePromise<unknown>;
+type PluginHostOptions = {
+    readonly loadPluginModule?: PluginModuleLoader;
+};
+export declare function toNativeLessValue(value: PluginRawArgument | ValueGroup): unknown;
+export declare function fromNativeLessValue(value: unknown): ValueGroup;
+export declare class LessApiBridge {
+    #private;
+    readonly less: NativeLessApi;
+    readonly registry: NativeLessFunctionRegistry;
+    readonly globalFns: readonly Fn[];
+    constructor(plugins?: readonly NativeLessPlugin[]);
+    addFunction(name: string, fn: NativeLessFunction): Fn;
+    addContextualFunction(name: string, fn: ContextualPluginFunction): Fn;
+    invokeNativeFunction(fn: NativeLessFunction, args: readonly PluginRawArgument[]): ValueGroup | Promise<ValueGroup>;
+    invokeContextualFunction(fn: ContextualPluginFunction, args: readonly PluginRawArgument[], ctx: PluginCallCtx): ValueGroup | Promise<ValueGroup>;
+    invokeRawFunction(fn: Fn, args: readonly PluginRawArgument[], ctx: PluginCallCtx): MaybePromise<ValueGroup | undefined>;
+    createPluginHost(optionsOrLoader?: PluginHostOptions | PluginModuleLoader): PluginHost;
+}
+export {};

package/lib/plugin.d.ts

@@ -1,92 +1,31 @@
-import { AbstractPlugin, type Plugin, type Visitor } from '@jesscss/core';
-import type { LessVisitor } from './types.js';
-import { NodeModulesPlugin } from '@jesscss/plugin-node-modules';
+import { AbstractPlugin, type Context } from '@jesscss/core';
+import type { Fn } from '@jesscss/core/value';
+import { type NativeLessPlugin } from './less-api-bridge.js';
+/**
+ * Native AST-v2 functions contributed by an application. Function bodies receive
+ * typed value objects and the narrow `FnCtx` capability supplied by core; they
+ * never receive Less tree nodes or a legacy evaluation context.
+ */
 export interface LessCompatPluginOptions {
-    /**
-     * Less.js plugins - these will have their install() method called to extract visitors.
-     * Can be mixed with Jess plugins - Less plugins will be handled by this compat layer,
-     * Jess plugins will be passed through.
-     */
-    plugins?: any[];
-    /**
-     * @deprecated Less.js Visitor API - Less.js visitor implementations (advanced - use plugins instead).
-     * This is for compatibility with Less.js visitor patterns. Prefer using Jess's native Visitor interface.
-     */
-    visitors?: LessVisitor[];
-    /** Enable conversion caching (default: true) */
-    cache?: boolean;
-    /**
-     * Plugin registry for @plugin directive support.
-     * Maps plugin names/paths to plugin instances or factory functions.
-     * Used when processing @plugin directives in the source.
-     */
-    pluginRegistry?: Record<string, any>;
-    /**
-     * Enable auto-loading of plugins by name (Less.js 4.x CLI behavior).
-     * When true (default), @plugin directives will attempt to require/import
-     * plugins by their npm package name (e.g., "less-plugin-autoprefix").
-     * Set to false to disable and only use pluginRegistry.
-     */
-    autoLoadPlugins?: boolean;
-    /**
-     * Reference to the node-modules plugin for npm package resolution.
-     * If provided, will be used to resolve npm packages.
-     * If not provided, will try to use require() directly.
-     */
-    nodeModulesPlugin?: NodeModulesPlugin;
+    readonly functions?: readonly Fn[];
+    readonly plugins?: readonly NativeLessPlugin[];
 }
 /**
- * Plugin that enables Less.js compatibility by transforming
- * Jess nodes to Less-compatible format for visitor processing.
+ * Transitional package boundary for applications that previously installed the
+ * Less compatibility plugin. It contributes only native AST-v2 `Fn` values.
+ *
+ * Less 4 visitor hooks, `functionRegistry` callbacks, and `@plugin` script
+ * execution were legacy tree-runtime APIs. They are intentionally unsupported
+ * on the public AST-v2 compiler route: preserving them would require a second
+ * evaluator and Node-to-Less/ Less-to-Node conversion bridge.
  */
 export declare class LessCompatPlugin extends AbstractPlugin {
-    opts: LessCompatPluginOptions;
+    readonly opts: LessCompatPluginOptions;
     name: string;
-    private _cachedVisitor;
-    private _lessPluginManager?;
-    private _currentFilePath?;
-    private _jessFunctionRegistry?;
+    private readonly bridges;
     constructor(opts?: LessCompatPluginOptions);
-    /**
-     * Return the visitor as a preEval visitor so it runs before evaluation.
-     * This ensures @plugin directives are processed early, allowing their visitors
-     * to run on subsequent nodes during the preEval phase.
-     *
-     * Less plugins can register visitors via:
-     * - addVisitor() - these will run during preEval (default)
-     * - addPreProcessor() - these will run during preEval
-     * - addPostProcessor() - these will run during postEval (after evaluation)
-     */
-    get preEvalVisitor(): Visitor | Visitor[] | undefined;
-    /**
-     * Return postEval visitors from Less plugins that registered via addPostProcessor.
-     * These visitors will run after node.eval() completes.
-     */
-    get postEvalVisitor(): undefined;
-    runPostProcessors(css: string, extra?: Record<string, any>): string;
-    setCurrentFilePath(filePath: string): void;
-    setContext(context: any): void;
-    /**
-     * Filter and separate Less plugins from Jess plugins
-     * This allows mixed plugin arrays to be handled correctly
-     *
-     * @deprecated Use filterPlugins from './plugin-utils.js' instead
-     */
-    static filterLessPlugins(plugins: any[]): {
-        lessPlugins: any[];
-        jessPlugins: import("@jesscss/core").PluginInterface[];
-    };
-    /**
-     * Return a visitor that wraps Less visitors
-     *
-     * This visitor intercepts each node, converts it to Less format,
-     * runs the Less visitors, and converts back if modified.
-     */
-    get visitor(): Visitor | Visitor[] | undefined;
+    setContext(context: Context): void;
 }
-/**
- * Create a Less.js compatibility plugin
- */
-declare const lessCompatPlugin: Plugin;
+declare const lessCompatPlugin: (opts?: LessCompatPluginOptions) => LessCompatPlugin;
 export default lessCompatPlugin;
 export { lessCompatPlugin };

package/package.json

@@ -3,26 +3,19 @@
   "publishConfig": {
     "access": "public"
   },
-  "description": "Less.js compatibility layer for Jess - enables Less plugins and visitors to work with Jess AST",
-  "version": "2.0.0-alpha.1",
+  "description": "Less function compatibility bridge for Jess",
+  "version": "2.0.0-alpha.10",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
   "type": "module",
-  "main": "lib/index.js",
+  "main": "lib/index.cjs",
   "types": "lib/index.d.ts",
   "exports": {
     ".": {
-      "import": "./lib/index.js",
       "types": "./lib/index.d.ts",
-      "source": "./src/index.ts"
-    },
-    "./transform": {
-      "import": "./lib/transform/index.js",
-      "types": "./lib/transform/index.d.ts",
-      "source": "./src/transform/index.ts"
-    },
-    "./less-compat-structures": {
-      "import": "./lib/less-compat-structures.js",
-      "types": "./lib/less-compat-structures.d.ts",
-      "source": "./src/less-compat-structures.ts"
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
     },
     "./package.json": "./package.json"
   },
@@ -30,9 +23,10 @@
     "lib"
   ],
   "dependencies": {
-    "@jesscss/core": "2.0.0-alpha.1",
-    "@jesscss/less-parser": "2.0.0-alpha.1",
-    "@jesscss/plugin-node-modules": "2.0.0-alpha.1"
+    "@jesscss/awaitable-pipe": "2.0.0-alpha.10",
+    "@jesscss/core": "2.0.0-alpha.10",
+    "@jesscss/less-parser": "2.0.0-alpha.10",
+    "@jesscss/plugin-node-modules": "2.0.0-alpha.10"
   },
   "devDependencies": {
     "less-plugin-autoprefix": "^2.0.0",
@@ -45,10 +39,11 @@
     "url": "https://github.com/jesscss/jess/issues"
   },
   "homepage": "https://github.com/jesscss/jess#readme",
+  "module": "lib/index.js",
   "scripts": {
     "ci": "pnpm build && pnpm test",
     "build": "pnpm compile",
-    "compile": "tsc -b tsconfig.build.json",
+    "compile": "tsdown --tsconfig tsconfig.build.json --no-dts && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "test": "cross-env TEST=true vitest --run",
     "lint:fix": "eslint --fix '**/*.{js,ts}'",
     "lint": "eslint '**/*.{js,ts}'"

package/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,gBAAgB,EAAgC,MAAM,aAAa,CAAC;AAC1G,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}