@cichol/sass-bridge 4.4.3 → 4.6.0

package/dists/index.cjs

@@ -0,0 +1,212 @@
+'use strict';
+
+var _Symbol = require('core-js-pure/stable/symbol/index.js');
+var _Promise = require('core-js-pure/stable/promise/index.js');
+var _mapInstanceProperty = require('core-js-pure/stable/instance/map.js');
+var _Reflect$construct = require('core-js-pure/stable/reflect/construct.js');
+var _Object$fromEntries = require('core-js-pure/stable/object/from-entries.js');
+require('reflect-metadata');
+var _fillInstanceProperty = require('core-js-pure/stable/instance/fill.js');
+var _Array$from = require('core-js-pure/stable/array/from.js');
+var _entriesInstanceProperty = require('core-js-pure/stable/instance/entries.js');
+var _Map = require('core-js-pure/stable/map/index.js');
+var _everyInstanceProperty = require('core-js-pure/stable/instance/every.js');
+var _Array$isArray = require('core-js-pure/stable/array/is-array.js');
+var chroma = require('chroma-js');
+var _filterInstanceProperty = require('core-js-pure/stable/instance/filter.js');
+var _Object$keys = require('core-js-pure/stable/object/keys.js');
+var _startsWithInstanceProperty = require('core-js-pure/stable/instance/starts-with.js');
+var _Object$getPrototypeOf = require('core-js-pure/stable/object/get-prototype-of.js');
+var sass = require('sass');
+
+function _interopNamespaceDefault(e) {
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n.default = e;
+	return Object.freeze(n);
+}
+
+var sass__namespace = /*#__PURE__*/_interopNamespaceDefault(sass);
+
+var _context, _context2, _context3, _context4, _context5;
+
+// Type definitions.
+
+const SassTypes = _Object$fromEntries(_mapInstanceProperty(_context = _filterInstanceProperty(_context2 = _filterInstanceProperty(_context3 = _mapInstanceProperty(_context4 = _filterInstanceProperty(_context5 = _Object$keys(sass__namespace)).call(_context5, propertyKey => _startsWithInstanceProperty(propertyKey).call(propertyKey, 'Sass'))).call(_context4, propertyKey => sass__namespace[propertyKey])).call(_context3, constructor => typeof constructor === 'function')).call(_context2, constructor => Object.prototype.isPrototypeOf.call(sass.Value.prototype, constructor.prototype))).call(_context, constructor => [constructor.name, constructor]));
+const SassTRUE = sass__namespace.sassTrue;
+const SassFALSE = sass__namespace.sassFalse;
+const SassNULL = sass__namespace.sassNull;
+const {
+  SassNumber
+} = SassTypes;
+const {
+  SassString
+} = SassTypes;
+const {
+  SassColor
+} = SassTypes;
+const {
+  SassList
+} = SassTypes;
+const {
+  SassMap
+} = SassTypes;
+const SassBoolean = _Object$getPrototypeOf(SassTRUE).constructor;
+
+// Helper functions.
+function isObject(value) {
+  const type = typeof value;
+  return !!value && (type === 'object' || type === 'function');
+}
+function sassToJavaScriptType(sassValue) {
+  switch (true) {
+    case sassValue instanceof SassBoolean:
+      {
+        return sassValue.value;
+      }
+    case sassValue instanceof SassString:
+      {
+        return sassValue.text;
+      }
+    case sassValue instanceof SassNumber:
+      {
+        const {
+          value,
+          numeratorUnits,
+          denominatorUnits
+        } = sassValue;
+        const unit = sassValue.hasUnits ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '') : '';
+        return unit ? {
+          value,
+          unit
+        } : value;
+      }
+    case sassValue instanceof SassColor:
+      {
+        const {
+          red,
+          green,
+          blue,
+          alpha
+        } = sassValue;
+        return chroma(red, green, blue, alpha);
+      }
+    case sassValue instanceof SassList:
+      {
+        var _context;
+        const listValue = sassValue.asList;
+        const length = listValue.size;
+        const array = _fillInstanceProperty(_context = Array(length)).call(_context, undefined);
+        for (let index = 0; index < length; index += 1) {
+          array[index] = listValue.get(index);
+        }
+        return _mapInstanceProperty(array).call(array, value => sassToJavaScriptType(value));
+      }
+    case sassValue instanceof SassMap:
+      {
+        var _context2;
+        const mapValue = sassValue.contents;
+        const entries = _mapInstanceProperty(_context2 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context2, ([key, value]) => [sassToJavaScriptType(key), sassToJavaScriptType(value)]);
+        return new _Map(entries);
+      }
+    default:
+      {
+        return null;
+      }
+  }
+}
+function javaScriptToSassType(rawValue) {
+  var _context3;
+  switch (true) {
+    case typeof rawValue === 'boolean':
+      {
+        const booleanValue = rawValue;
+        return booleanValue ? SassTRUE : SassFALSE;
+      }
+    case typeof rawValue === 'number':
+      {
+        const numberValue = rawValue;
+        return new SassNumber(numberValue);
+      }
+    case isObject(rawValue) && _everyInstanceProperty(_context3 = ['value', 'unit']).call(_context3, propertyKey => propertyKey in rawValue):
+      {
+        const {
+          value,
+          unit
+        } = rawValue;
+        return new SassNumber(value, unit);
+      }
+    case typeof rawValue === 'string':
+      {
+        const stringValue = rawValue;
+        return new SassString(stringValue);
+      }
+    case isObject(rawValue) && '_rgb' in rawValue:
+      {
+        const [red, green, blue, alpha] = rawValue.rgba();
+        return new SassColor({
+          red,
+          green,
+          blue,
+          alpha
+        });
+      }
+    case _Array$isArray(rawValue):
+      {
+        return new SassList(_mapInstanceProperty(rawValue).call(rawValue, value => javaScriptToSassType(value)));
+      }
+    case rawValue instanceof _Map:
+      {
+        var _context4;
+        const mapValue = rawValue;
+        const sassMap = new SassMap();
+        const converted = _mapInstanceProperty(_context4 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context4, entry => _mapInstanceProperty(entry).call(entry, javaScriptToSassType));
+        for (const [key, value] of converted) {
+          sassMap.contents.set(key, value);
+        }
+        return sassMap;
+      }
+    default:
+      {
+        return SassNULL;
+      }
+  }
+}
+
+// Type definitions.
+
+// Constants.
+const KeyOfSignature = _Symbol('@cichol/sass-bridge::KeyOfSignature');
+function sassFunction(definition) {
+  return target => {
+    Reflect.defineMetadata(KeyOfSignature, definition, target);
+    return target;
+  };
+}
+async function getFunctions(...moduleImports) {
+  const modules = await _Promise.all(_mapInstanceProperty(moduleImports).call(moduleImports, module => _Promise.resolve(module).then(module => module.default)));
+  const entries = _mapInstanceProperty(modules).call(modules, module => {
+    const signature = Reflect.getMetadata(KeyOfSignature, module);
+    async function customFunction(rawArgs) {
+      const args = _mapInstanceProperty(rawArgs).call(rawArgs, sassToJavaScriptType);
+      const result = await _Reflect$construct(module, args).execute();
+      return javaScriptToSassType(result);
+    }
+    return [signature, customFunction];
+  });
+  return _Object$fromEntries(entries);
+}
+
+exports.getFunctions = getFunctions;
+exports.sassFunction = sassFunction;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.cjs","sources":["../sources/types.ts","../sources/type-converter.ts","../sources/index.ts"],"sourcesContent":["// Third-party modules.\nimport type { Color } from 'chroma-js'\nimport * as sass from 'sass'\nimport { Value } from 'sass'\n\n// Type definitions.\nexport type Primitives = boolean | number | string | null\n\nexport type NumberWithUnit = { value: number, unit: string }\n\nexport type JavaScriptType<Base = Primitives | Color | NumberWithUnit> =\n\t| Base\n\t| JavaScriptType<Base>[]\n\t| Map<JavaScriptType<Base>, JavaScriptType<Base>>\n\ntype FilterSassPrefix<T extends string> = T extends `Sass${infer R}` ? R : never\n\ntype SassTypes = Exclude<`Sass${FilterSassPrefix<keyof typeof sass>}`, `Sass${'Boolean' | 'Calculation'}`>\n\nconst SassTypes = Object.fromEntries(\n\tObject.keys(sass)\n\t\t.filter(propertyKey => propertyKey.startsWith('Sass'))\n\t\t.map(propertyKey => sass[propertyKey as SassTypes])\n\t\t.filter(constructor => typeof constructor === 'function')\n\t\t.filter(constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))\n\t\t.map(constructor => [ constructor.name, constructor ] as [SassTypes, (typeof sass)[SassTypes]]),\n) as { [P in SassTypes]: (typeof sass)[P] }\n\nexport const SassTRUE = sass.sassTrue\nexport type SassTRUE = typeof SassTRUE\n\nexport const SassFALSE = sass.sassFalse\nexport type SassFALSE = typeof SassFALSE\n\nexport const SassNULL = sass.sassNull\nexport type SassNULL = typeof SassNULL\n\nexport const { SassNumber } = SassTypes\nexport type SassNumber = InstanceType<typeof SassNumber>\n\nexport const { SassString } = SassTypes\nexport type SassString = InstanceType<typeof SassString>\n\nexport const { SassColor } = SassTypes\nexport type SassColor = InstanceType<typeof SassColor>\n\nexport const { SassList } = SassTypes\nexport type SassList = InstanceType<typeof SassList>\n\nexport const { SassMap } = SassTypes\nexport type SassMap = InstanceType<typeof SassMap>\n\nexport const SassBoolean = Object.getPrototypeOf(SassTRUE).constructor as typeof sass.SassBoolean\nexport type SassBoolean = sass.SassBoolean\n\nexport type SassType =\n\t| InstanceType<typeof SassTypes extends Record<any, infer R> ? R : never>\n\t| SassBoolean\n","// Third-party modules.\nimport chroma from 'chroma-js'\n\n// Local helpers.\nimport {\n\ttype SassType,\n\tSassBoolean,\n\tSassNumber,\n\tSassString,\n\tSassColor,\n\tSassList,\n\tSassMap,\n\tSassTRUE,\n\tSassFALSE,\n\tSassNULL,\n\ttype JavaScriptType,\n\ttype NumberWithUnit,\n} from './types'\n\n// Helper functions.\nfunction isObject(value?: unknown): value is object {\n\tconst type = typeof value\n\n\treturn !!value && (type === 'object' || type === 'function')\n}\n\nexport function sassToJavaScriptType(sassValue: SassType): JavaScriptType {\n\tswitch (true) {\n\tcase sassValue instanceof SassBoolean: {\n\t\treturn sassValue.value\n\t}\n\n\tcase sassValue instanceof SassString: {\n\t\treturn sassValue.text\n\t}\n\n\tcase sassValue instanceof SassNumber: {\n\t\tconst { value, numeratorUnits, denominatorUnits } = sassValue\n\n\t\tconst unit = sassValue.hasUnits\n\t\t\t? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '')\n\t\t\t: ''\n\n\t\treturn unit ? { value, unit } : value\n\t}\n\n\tcase sassValue instanceof SassColor: {\n\t\tconst { red, green, blue, alpha } = sassValue\n\n\t\treturn chroma(red, green, blue, alpha)\n\t}\n\n\tcase sassValue instanceof SassList: {\n\t\tconst listValue = sassValue.asList\n\t\tconst length = listValue.size\n\t\tconst array = Array(length).fill(undefined) as SassType[]\n\n\t\tfor (let index = 0; index < length; index += 1) {\n\t\t\tarray[index] = listValue.get(index) as SassType\n\t\t}\n\n\t\treturn array.map(value => sassToJavaScriptType(value))\n\t}\n\n\tcase sassValue instanceof SassMap: {\n\t\tconst mapValue = sassValue.contents\n\n\t\tconst entries = Array.from(mapValue.entries() as IterableIterator<[SassType, SassType]>)\n\t\t\t.map(([ key, value ]) => [ sassToJavaScriptType(key), sassToJavaScriptType(value) ])\n\n\t\treturn new Map(entries as [JavaScriptType, JavaScriptType][])\n\t}\n\n\tdefault: {\n\t\treturn null\n\t}\n\t}\n}\n\nexport function javaScriptToSassType(rawValue: JavaScriptType): SassType {\n\tswitch (true) {\n\tcase typeof rawValue === 'boolean': {\n\t\tconst booleanValue = rawValue\n\n\t\treturn booleanValue ? SassTRUE : SassFALSE\n\t}\n\n\tcase typeof rawValue === 'number': {\n\t\tconst numberValue = rawValue\n\n\t\treturn new SassNumber(numberValue)\n\t}\n\n\tcase isObject(rawValue) && [ 'value', 'unit' ].every(propertyKey => propertyKey in rawValue): {\n\t\tconst { value, unit } = rawValue as NumberWithUnit\n\n\t\treturn new SassNumber(value, unit)\n\t}\n\n\tcase typeof rawValue === 'string': {\n\t\tconst stringValue = rawValue\n\n\t\treturn new SassString(stringValue)\n\t}\n\n\tcase isObject(rawValue) && '_rgb' in rawValue: {\n\t\tconst [ red, green, blue, alpha ] = rawValue.rgba() as number[]\n\n\t\treturn new SassColor({ red, green, blue, alpha })\n\t}\n\n\tcase Array.isArray(rawValue): {\n\t\treturn new SassList(rawValue.map(value => javaScriptToSassType(value)))\n\t}\n\n\tcase rawValue instanceof Map: {\n\t\tconst mapValue = rawValue as Map<JavaScriptType, JavaScriptType>\n\t\tconst sassMap = new SassMap()\n\n\t\tconst converted = Array.from(mapValue.entries())\n\t\t\t.map(entry => entry.map(javaScriptToSassType)) as [SassType, SassType][]\n\n\t\tfor (const [ key, value ] of converted) {\n\t\t\tsassMap.contents.set(key, value)\n\t\t}\n\n\t\treturn sassMap\n\t}\n\n\tdefault: {\n\t\treturn SassNULL\n\t}\n\t}\n}\n","import 'reflect-metadata'\n\n// Third-party modules.\nimport { CustomFunction } from 'sass'\n\n// Local helpers.\nimport type { SassType, JavaScriptType } from './types'\nimport { sassToJavaScriptType, javaScriptToSassType } from './type-converter'\n\n// Type definitions.\nexport interface BridgedFunction {\n\texecute(): JavaScriptType | Promise<JavaScriptType>\n}\n\nexport interface Constructor {\n\tnew (...args: any[]): BridgedFunction\n}\n\n// Constants.\nconst KeyOfSignature = Symbol('@cichol/sass-bridge::KeyOfSignature')\n\nexport function sassFunction(definition: string): ClassDecorator {\n\treturn (<T extends Constructor>(target: T) => {\n\t\tReflect.defineMetadata(KeyOfSignature, definition, target)\n\n\t\treturn target\n\t}) as ClassDecorator\n}\n\nexport async function getFunctions(\n\t...moduleImports: Promise<{ default: Constructor }>[]\n): Promise<Record<string, CustomFunction<'async'>>> {\n\tconst modules = await Promise.all(\n\t\tmoduleImports.map(module => (\n\t\t\tPromise.resolve(module)\n\t\t\t\t.then(module => module.default)\n\t\t)),\n\t)\n\n\tconst entries = modules.map(module => {\n\t\tconst signature = Reflect.getMetadata(KeyOfSignature, module) as string\n\n\t\tasync function customFunction(rawArgs: SassType[]): Promise<SassType> {\n\t\t\tconst args = rawArgs.map(sassToJavaScriptType)\n\t\t\tconst result = await Reflect.construct(module, args).execute()\n\n\t\t\treturn javaScriptToSassType(result)\n\t\t}\n\n\t\treturn [ signature, customFunction ] as const\n\t})\n\n\treturn Object.fromEntries(entries)\n}\n"],"names":["SassTypes","_Object$fromEntries","_mapInstanceProperty","_context","_filterInstanceProperty","_context2","_context3","_context4","_context5","_Object$keys","sass","call","propertyKey","_startsWithInstanceProperty","constructor","Object","prototype","isPrototypeOf","Value","name","SassTRUE","sassTrue","SassFALSE","sassFalse","SassNULL","sassNull","SassNumber","SassString","SassColor","SassList","SassMap","SassBoolean","_Object$getPrototypeOf","isObject","value","type","sassToJavaScriptType","sassValue","text","numeratorUnits","denominatorUnits","unit","hasUnits","join","size","red","green","blue","alpha","chroma","listValue","asList","length","array","_fillInstanceProperty","Array","undefined","index","get","mapValue","contents","entries","_Array$from","_entriesInstanceProperty","key","_Map","javaScriptToSassType","rawValue","booleanValue","numberValue","_everyInstanceProperty","stringValue","rgba","_Array$isArray","sassMap","converted","entry","set","KeyOfSignature","_Symbol","sassFunction","definition","target","Reflect","defineMetadata","getFunctions","moduleImports","modules","_Promise","all","module","resolve","then","default","signature","getMetadata","customFunction","rawArgs","args","result","_Reflect$construct","execute"],"mappings":"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"}

package/dists/index.d.cts

@@ -0,0 +1,27 @@
+import type { Color } from 'chroma-js';
+import { CustomFunction } from 'sass';
+
+export declare interface BridgedFunction {
+    execute(): JavaScriptType | Promise<JavaScriptType>;
+}
+
+export declare interface Constructor {
+    new (...args: any[]): BridgedFunction;
+}
+
+export declare function getFunctions(...moduleImports: Promise<{
+    default: Constructor;
+}>[]): Promise<Record<string, CustomFunction<'async'>>>;
+
+declare type JavaScriptType<Base = Primitives | Color | NumberWithUnit> = Base | JavaScriptType<Base>[] | Map<JavaScriptType<Base>, JavaScriptType<Base>>;
+
+declare type NumberWithUnit = {
+    value: number;
+    unit: string;
+};
+
+declare type Primitives = boolean | number | string | null;
+
+export declare function sassFunction(definition: string): ClassDecorator;
+
+export { }

package/dists/index.d.ts

@@ -0,0 +1,27 @@
+import type { Color } from 'chroma-js';
+import { CustomFunction } from 'sass';
+
+export declare interface BridgedFunction {
+    execute(): JavaScriptType | Promise<JavaScriptType>;
+}
+
+export declare interface Constructor {
+    new (...args: any[]): BridgedFunction;
+}
+
+export declare function getFunctions(...moduleImports: Promise<{
+    default: Constructor;
+}>[]): Promise<Record<string, CustomFunction<'async'>>>;
+
+declare type JavaScriptType<Base = Primitives | Color | NumberWithUnit> = Base | JavaScriptType<Base>[] | Map<JavaScriptType<Base>, JavaScriptType<Base>>;
+
+declare type NumberWithUnit = {
+    value: number;
+    unit: string;
+};
+
+declare type Primitives = boolean | number | string | null;
+
+export declare function sassFunction(definition: string): ClassDecorator;
+
+export { }

package/dists/index.js

@@ -0,0 +1,191 @@
+import _Symbol from 'core-js-pure/stable/symbol/index.js';
+import _Promise from 'core-js-pure/stable/promise/index.js';
+import _mapInstanceProperty from 'core-js-pure/stable/instance/map.js';
+import _Reflect$construct from 'core-js-pure/stable/reflect/construct.js';
+import _Object$fromEntries from 'core-js-pure/stable/object/from-entries.js';
+import 'reflect-metadata';
+import _fillInstanceProperty from 'core-js-pure/stable/instance/fill.js';
+import _Array$from from 'core-js-pure/stable/array/from.js';
+import _entriesInstanceProperty from 'core-js-pure/stable/instance/entries.js';
+import _Map from 'core-js-pure/stable/map/index.js';
+import _everyInstanceProperty from 'core-js-pure/stable/instance/every.js';
+import _Array$isArray from 'core-js-pure/stable/array/is-array.js';
+import chroma from 'chroma-js';
+import _filterInstanceProperty from 'core-js-pure/stable/instance/filter.js';
+import _Object$keys from 'core-js-pure/stable/object/keys.js';
+import _startsWithInstanceProperty from 'core-js-pure/stable/instance/starts-with.js';
+import _Object$getPrototypeOf from 'core-js-pure/stable/object/get-prototype-of.js';
+import * as sass from 'sass';
+import { Value } from 'sass';
+
+var _context, _context2, _context3, _context4, _context5;
+
+// Type definitions.
+
+const SassTypes = _Object$fromEntries(_mapInstanceProperty(_context = _filterInstanceProperty(_context2 = _filterInstanceProperty(_context3 = _mapInstanceProperty(_context4 = _filterInstanceProperty(_context5 = _Object$keys(sass)).call(_context5, propertyKey => _startsWithInstanceProperty(propertyKey).call(propertyKey, 'Sass'))).call(_context4, propertyKey => sass[propertyKey])).call(_context3, constructor => typeof constructor === 'function')).call(_context2, constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))).call(_context, constructor => [constructor.name, constructor]));
+const SassTRUE = sass.sassTrue;
+const SassFALSE = sass.sassFalse;
+const SassNULL = sass.sassNull;
+const {
+  SassNumber
+} = SassTypes;
+const {
+  SassString
+} = SassTypes;
+const {
+  SassColor
+} = SassTypes;
+const {
+  SassList
+} = SassTypes;
+const {
+  SassMap
+} = SassTypes;
+const SassBoolean = _Object$getPrototypeOf(SassTRUE).constructor;
+
+// Helper functions.
+function isObject(value) {
+  const type = typeof value;
+  return !!value && (type === 'object' || type === 'function');
+}
+function sassToJavaScriptType(sassValue) {
+  switch (true) {
+    case sassValue instanceof SassBoolean:
+      {
+        return sassValue.value;
+      }
+    case sassValue instanceof SassString:
+      {
+        return sassValue.text;
+      }
+    case sassValue instanceof SassNumber:
+      {
+        const {
+          value,
+          numeratorUnits,
+          denominatorUnits
+        } = sassValue;
+        const unit = sassValue.hasUnits ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '') : '';
+        return unit ? {
+          value,
+          unit
+        } : value;
+      }
+    case sassValue instanceof SassColor:
+      {
+        const {
+          red,
+          green,
+          blue,
+          alpha
+        } = sassValue;
+        return chroma(red, green, blue, alpha);
+      }
+    case sassValue instanceof SassList:
+      {
+        var _context;
+        const listValue = sassValue.asList;
+        const length = listValue.size;
+        const array = _fillInstanceProperty(_context = Array(length)).call(_context, undefined);
+        for (let index = 0; index < length; index += 1) {
+          array[index] = listValue.get(index);
+        }
+        return _mapInstanceProperty(array).call(array, value => sassToJavaScriptType(value));
+      }
+    case sassValue instanceof SassMap:
+      {
+        var _context2;
+        const mapValue = sassValue.contents;
+        const entries = _mapInstanceProperty(_context2 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context2, ([key, value]) => [sassToJavaScriptType(key), sassToJavaScriptType(value)]);
+        return new _Map(entries);
+      }
+    default:
+      {
+        return null;
+      }
+  }
+}
+function javaScriptToSassType(rawValue) {
+  var _context3;
+  switch (true) {
+    case typeof rawValue === 'boolean':
+      {
+        const booleanValue = rawValue;
+        return booleanValue ? SassTRUE : SassFALSE;
+      }
+    case typeof rawValue === 'number':
+      {
+        const numberValue = rawValue;
+        return new SassNumber(numberValue);
+      }
+    case isObject(rawValue) && _everyInstanceProperty(_context3 = ['value', 'unit']).call(_context3, propertyKey => propertyKey in rawValue):
+      {
+        const {
+          value,
+          unit
+        } = rawValue;
+        return new SassNumber(value, unit);
+      }
+    case typeof rawValue === 'string':
+      {
+        const stringValue = rawValue;
+        return new SassString(stringValue);
+      }
+    case isObject(rawValue) && '_rgb' in rawValue:
+      {
+        const [red, green, blue, alpha] = rawValue.rgba();
+        return new SassColor({
+          red,
+          green,
+          blue,
+          alpha
+        });
+      }
+    case _Array$isArray(rawValue):
+      {
+        return new SassList(_mapInstanceProperty(rawValue).call(rawValue, value => javaScriptToSassType(value)));
+      }
+    case rawValue instanceof _Map:
+      {
+        var _context4;
+        const mapValue = rawValue;
+        const sassMap = new SassMap();
+        const converted = _mapInstanceProperty(_context4 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context4, entry => _mapInstanceProperty(entry).call(entry, javaScriptToSassType));
+        for (const [key, value] of converted) {
+          sassMap.contents.set(key, value);
+        }
+        return sassMap;
+      }
+    default:
+      {
+        return SassNULL;
+      }
+  }
+}
+
+// Type definitions.
+
+// Constants.
+const KeyOfSignature = _Symbol('@cichol/sass-bridge::KeyOfSignature');
+function sassFunction(definition) {
+  return target => {
+    Reflect.defineMetadata(KeyOfSignature, definition, target);
+    return target;
+  };
+}
+async function getFunctions(...moduleImports) {
+  const modules = await _Promise.all(_mapInstanceProperty(moduleImports).call(moduleImports, module => _Promise.resolve(module).then(module => module.default)));
+  const entries = _mapInstanceProperty(modules).call(modules, module => {
+    const signature = Reflect.getMetadata(KeyOfSignature, module);
+    async function customFunction(rawArgs) {
+      const args = _mapInstanceProperty(rawArgs).call(rawArgs, sassToJavaScriptType);
+      const result = await _Reflect$construct(module, args).execute();
+      return javaScriptToSassType(result);
+    }
+    return [signature, customFunction];
+  });
+  return _Object$fromEntries(entries);
+}
+
+export { getFunctions, sassFunction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../sources/types.ts","../sources/type-converter.ts","../sources/index.ts"],"sourcesContent":["// Third-party modules.\nimport type { Color } from 'chroma-js'\nimport * as sass from 'sass'\nimport { Value } from 'sass'\n\n// Type definitions.\nexport type Primitives = boolean | number | string | null\n\nexport type NumberWithUnit = { value: number, unit: string }\n\nexport type JavaScriptType<Base = Primitives | Color | NumberWithUnit> =\n\t| Base\n\t| JavaScriptType<Base>[]\n\t| Map<JavaScriptType<Base>, JavaScriptType<Base>>\n\ntype FilterSassPrefix<T extends string> = T extends `Sass${infer R}` ? R : never\n\ntype SassTypes = Exclude<`Sass${FilterSassPrefix<keyof typeof sass>}`, `Sass${'Boolean' | 'Calculation'}`>\n\nconst SassTypes = Object.fromEntries(\n\tObject.keys(sass)\n\t\t.filter(propertyKey => propertyKey.startsWith('Sass'))\n\t\t.map(propertyKey => sass[propertyKey as SassTypes])\n\t\t.filter(constructor => typeof constructor === 'function')\n\t\t.filter(constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))\n\t\t.map(constructor => [ constructor.name, constructor ] as [SassTypes, (typeof sass)[SassTypes]]),\n) as { [P in SassTypes]: (typeof sass)[P] }\n\nexport const SassTRUE = sass.sassTrue\nexport type SassTRUE = typeof SassTRUE\n\nexport const SassFALSE = sass.sassFalse\nexport type SassFALSE = typeof SassFALSE\n\nexport const SassNULL = sass.sassNull\nexport type SassNULL = typeof SassNULL\n\nexport const { SassNumber } = SassTypes\nexport type SassNumber = InstanceType<typeof SassNumber>\n\nexport const { SassString } = SassTypes\nexport type SassString = InstanceType<typeof SassString>\n\nexport const { SassColor } = SassTypes\nexport type SassColor = InstanceType<typeof SassColor>\n\nexport const { SassList } = SassTypes\nexport type SassList = InstanceType<typeof SassList>\n\nexport const { SassMap } = SassTypes\nexport type SassMap = InstanceType<typeof SassMap>\n\nexport const SassBoolean = Object.getPrototypeOf(SassTRUE).constructor as typeof sass.SassBoolean\nexport type SassBoolean = sass.SassBoolean\n\nexport type SassType =\n\t| InstanceType<typeof SassTypes extends Record<any, infer R> ? R : never>\n\t| SassBoolean\n","// Third-party modules.\nimport chroma from 'chroma-js'\n\n// Local helpers.\nimport {\n\ttype SassType,\n\tSassBoolean,\n\tSassNumber,\n\tSassString,\n\tSassColor,\n\tSassList,\n\tSassMap,\n\tSassTRUE,\n\tSassFALSE,\n\tSassNULL,\n\ttype JavaScriptType,\n\ttype NumberWithUnit,\n} from './types'\n\n// Helper functions.\nfunction isObject(value?: unknown): value is object {\n\tconst type = typeof value\n\n\treturn !!value && (type === 'object' || type === 'function')\n}\n\nexport function sassToJavaScriptType(sassValue: SassType): JavaScriptType {\n\tswitch (true) {\n\tcase sassValue instanceof SassBoolean: {\n\t\treturn sassValue.value\n\t}\n\n\tcase sassValue instanceof SassString: {\n\t\treturn sassValue.text\n\t}\n\n\tcase sassValue instanceof SassNumber: {\n\t\tconst { value, numeratorUnits, denominatorUnits } = sassValue\n\n\t\tconst unit = sassValue.hasUnits\n\t\t\t? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '')\n\t\t\t: ''\n\n\t\treturn unit ? { value, unit } : value\n\t}\n\n\tcase sassValue instanceof SassColor: {\n\t\tconst { red, green, blue, alpha } = sassValue\n\n\t\treturn chroma(red, green, blue, alpha)\n\t}\n\n\tcase sassValue instanceof SassList: {\n\t\tconst listValue = sassValue.asList\n\t\tconst length = listValue.size\n\t\tconst array = Array(length).fill(undefined) as SassType[]\n\n\t\tfor (let index = 0; index < length; index += 1) {\n\t\t\tarray[index] = listValue.get(index) as SassType\n\t\t}\n\n\t\treturn array.map(value => sassToJavaScriptType(value))\n\t}\n\n\tcase sassValue instanceof SassMap: {\n\t\tconst mapValue = sassValue.contents\n\n\t\tconst entries = Array.from(mapValue.entries() as IterableIterator<[SassType, SassType]>)\n\t\t\t.map(([ key, value ]) => [ sassToJavaScriptType(key), sassToJavaScriptType(value) ])\n\n\t\treturn new Map(entries as [JavaScriptType, JavaScriptType][])\n\t}\n\n\tdefault: {\n\t\treturn null\n\t}\n\t}\n}\n\nexport function javaScriptToSassType(rawValue: JavaScriptType): SassType {\n\tswitch (true) {\n\tcase typeof rawValue === 'boolean': {\n\t\tconst booleanValue = rawValue\n\n\t\treturn booleanValue ? SassTRUE : SassFALSE\n\t}\n\n\tcase typeof rawValue === 'number': {\n\t\tconst numberValue = rawValue\n\n\t\treturn new SassNumber(numberValue)\n\t}\n\n\tcase isObject(rawValue) && [ 'value', 'unit' ].every(propertyKey => propertyKey in rawValue): {\n\t\tconst { value, unit } = rawValue as NumberWithUnit\n\n\t\treturn new SassNumber(value, unit)\n\t}\n\n\tcase typeof rawValue === 'string': {\n\t\tconst stringValue = rawValue\n\n\t\treturn new SassString(stringValue)\n\t}\n\n\tcase isObject(rawValue) && '_rgb' in rawValue: {\n\t\tconst [ red, green, blue, alpha ] = rawValue.rgba() as number[]\n\n\t\treturn new SassColor({ red, green, blue, alpha })\n\t}\n\n\tcase Array.isArray(rawValue): {\n\t\treturn new SassList(rawValue.map(value => javaScriptToSassType(value)))\n\t}\n\n\tcase rawValue instanceof Map: {\n\t\tconst mapValue = rawValue as Map<JavaScriptType, JavaScriptType>\n\t\tconst sassMap = new SassMap()\n\n\t\tconst converted = Array.from(mapValue.entries())\n\t\t\t.map(entry => entry.map(javaScriptToSassType)) as [SassType, SassType][]\n\n\t\tfor (const [ key, value ] of converted) {\n\t\t\tsassMap.contents.set(key, value)\n\t\t}\n\n\t\treturn sassMap\n\t}\n\n\tdefault: {\n\t\treturn SassNULL\n\t}\n\t}\n}\n","import 'reflect-metadata'\n\n// Third-party modules.\nimport { CustomFunction } from 'sass'\n\n// Local helpers.\nimport type { SassType, JavaScriptType } from './types'\nimport { sassToJavaScriptType, javaScriptToSassType } from './type-converter'\n\n// Type definitions.\nexport interface BridgedFunction {\n\texecute(): JavaScriptType | Promise<JavaScriptType>\n}\n\nexport interface Constructor {\n\tnew (...args: any[]): BridgedFunction\n}\n\n// Constants.\nconst KeyOfSignature = Symbol('@cichol/sass-bridge::KeyOfSignature')\n\nexport function sassFunction(definition: string): ClassDecorator {\n\treturn (<T extends Constructor>(target: T) => {\n\t\tReflect.defineMetadata(KeyOfSignature, definition, target)\n\n\t\treturn target\n\t}) as ClassDecorator\n}\n\nexport async function getFunctions(\n\t...moduleImports: Promise<{ default: Constructor }>[]\n): Promise<Record<string, CustomFunction<'async'>>> {\n\tconst modules = await Promise.all(\n\t\tmoduleImports.map(module => (\n\t\t\tPromise.resolve(module)\n\t\t\t\t.then(module => module.default)\n\t\t)),\n\t)\n\n\tconst entries = modules.map(module => {\n\t\tconst signature = Reflect.getMetadata(KeyOfSignature, module) as string\n\n\t\tasync function customFunction(rawArgs: SassType[]): Promise<SassType> {\n\t\t\tconst args = rawArgs.map(sassToJavaScriptType)\n\t\t\tconst result = await Reflect.construct(module, args).execute()\n\n\t\t\treturn javaScriptToSassType(result)\n\t\t}\n\n\t\treturn [ signature, customFunction ] as const\n\t})\n\n\treturn Object.fromEntries(entries)\n}\n"],"names":["SassTypes","_Object$fromEntries","_mapInstanceProperty","_context","_filterInstanceProperty","_context2","_context3","_context4","_context5","_Object$keys","sass","call","propertyKey","_startsWithInstanceProperty","constructor","Object","prototype","isPrototypeOf","Value","name","SassTRUE","sassTrue","SassFALSE","sassFalse","SassNULL","sassNull","SassNumber","SassString","SassColor","SassList","SassMap","SassBoolean","_Object$getPrototypeOf","isObject","value","type","sassToJavaScriptType","sassValue","text","numeratorUnits","denominatorUnits","unit","hasUnits","join","size","red","green","blue","alpha","chroma","listValue","asList","length","array","_fillInstanceProperty","Array","undefined","index","get","mapValue","contents","entries","_Array$from","_entriesInstanceProperty","key","_Map","javaScriptToSassType","rawValue","booleanValue","numberValue","_everyInstanceProperty","stringValue","rgba","_Array$isArray","sassMap","converted","entry","set","KeyOfSignature","_Symbol","sassFunction","definition","target","Reflect","defineMetadata","getFunctions","moduleImports","modules","_Promise","all","module","resolve","then","default","signature","getMetadata","customFunction","rawArgs","args","result","_Reflect$construct","execute"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAKA;;AAcA,MAAMA,SAAS,GAAGC,mBAAA,CACjBC,oBAAA,CAAAC,QAAA,GAAAC,uBAAA,CAAAC,SAAA,GAAAD,uBAAA,CAAAE,SAAA,GAAAJ,oBAAA,CAAAK,SAAA,GAAAH,uBAAA,CAAAI,SAAA,GAAAC,YAAA,CAAYC,IAAI,CAAC,CAAA,CAAAC,IAAA,CAAAH,SAAA,EACRI,WAAW,IAAIC,2BAAA,CAAAD,WAAW,CAAAD,CAAAA,IAAA,CAAXC,WAAW,EAAY,MAAM,CAAC,CAAC,CAAA,CAAAD,IAAA,CAAAJ,SAAA,EACjDK,WAAW,IAAIF,IAAI,CAACE,WAAW,CAAc,CAAC,CAAA,CAAAD,IAAA,CAAAL,SAAA,EAC3CQ,WAAW,IAAI,OAAOA,WAAW,KAAK,UAAU,CAAC,CAAA,CAAAH,IAAA,CAAAN,SAAA,EACjDS,WAAW,IAAIC,MAAM,CAACC,SAAS,CAACC,aAAa,CAACN,IAAI,CAACO,KAAK,CAACF,SAAS,EAAEF,WAAW,CAACE,SAAS,CAAC,CAAC,CAAAL,CAAAA,IAAA,CAAAR,QAAA,EAC9FW,WAAW,IAAI,CAAEA,WAAW,CAACK,IAAI,EAAEL,WAAW,CAA2C,CAChG,CAA2C;AAEpC,MAAMM,QAAQ,GAAGV,IAAI,CAACW,QAAQ;AAG9B,MAAMC,SAAS,GAAGZ,IAAI,CAACa,SAAS;AAGhC,MAAMC,QAAQ,GAAGd,IAAI,CAACe,QAAQ;AAG9B,MAAM;AAAEC,EAAAA;AAAW,CAAC,GAAG1B,SAAS;AAGhC,MAAM;AAAE2B,EAAAA;AAAW,CAAC,GAAG3B,SAAS;AAGhC,MAAM;AAAE4B,EAAAA;AAAU,CAAC,GAAG5B,SAAS;AAG/B,MAAM;AAAE6B,EAAAA;AAAS,CAAC,GAAG7B,SAAS;AAG9B,MAAM;AAAE8B,EAAAA;AAAQ,CAAC,GAAG9B,SAAS;AAG7B,MAAM+B,WAAW,GAAGC,sBAAA,CAAsBZ,QAAQ,CAAC,CAACN,WAAsC;;ACjCjG;AACA,SAASmB,QAAQA,CAACC,KAAe,EAAmB;EACnD,MAAMC,IAAI,GAAG,OAAOD,KAAK;EAEzB,OAAO,CAAC,CAACA,KAAK,KAAKC,IAAI,KAAK,QAAQ,IAAIA,IAAI,KAAK,UAAU,CAAC;AAC7D;AAEO,SAASC,oBAAoBA,CAACC,SAAmB,EAAkB;AACzE,EAAA,QAAQ,IAAI;IACZ,KAAKA,SAAS,YAAYN,WAAW;AAAE,MAAA;QACtC,OAAOM,SAAS,CAACH,KAAK;AACvB;IAEA,KAAKG,SAAS,YAAYV,UAAU;AAAE,MAAA;QACrC,OAAOU,SAAS,CAACC,IAAI;AACtB;IAEA,KAAKD,SAAS,YAAYX,UAAU;AAAE,MAAA;QACrC,MAAM;UAAEQ,KAAK;UAAEK,cAAc;AAAEC,UAAAA;AAAiB,SAAC,GAAGH,SAAS;AAE7D,QAAA,MAAMI,IAAI,GAAGJ,SAAS,CAACK,QAAQ,GAC5BH,cAAc,CAACI,IAAI,CAAC,GAAG,CAAC,IAAIH,gBAAgB,CAACI,IAAI,GAAG,CAAC,GAAG,CAAIJ,CAAAA,EAAAA,gBAAgB,CAACG,IAAI,CAAC,GAAG,CAAC,CAAE,CAAA,GAAG,EAAE,CAAC,GAC9F,EAAE;AAEL,QAAA,OAAOF,IAAI,GAAG;UAAEP,KAAK;AAAEO,UAAAA;AAAK,SAAC,GAAGP,KAAK;AACtC;IAEA,KAAKG,SAAS,YAAYT,SAAS;AAAE,MAAA;QACpC,MAAM;UAAEiB,GAAG;UAAEC,KAAK;UAAEC,IAAI;AAAEC,UAAAA;AAAM,SAAC,GAAGX,SAAS;QAE7C,OAAOY,MAAM,CAACJ,GAAG,EAAEC,KAAK,EAAEC,IAAI,EAAEC,KAAK,CAAC;AACvC;IAEA,KAAKX,SAAS,YAAYR,QAAQ;AAAE,MAAA;AAAA,QAAA,IAAA1B,QAAA;AACnC,QAAA,MAAM+C,SAAS,GAAGb,SAAS,CAACc,MAAM;AAClC,QAAA,MAAMC,MAAM,GAAGF,SAAS,CAACN,IAAI;AAC7B,QAAA,MAAMS,KAAK,GAAGC,qBAAA,CAAAnD,QAAA,GAAAoD,KAAK,CAACH,MAAM,CAAC,EAAAzC,IAAA,CAAAR,QAAA,EAAMqD,SAAS,CAAe;AAEzD,QAAA,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGL,MAAM,EAAEK,KAAK,IAAI,CAAC,EAAE;UAC/CJ,KAAK,CAACI,KAAK,CAAC,GAAGP,SAAS,CAACQ,GAAG,CAACD,KAAK,CAAa;AAChD;AAEA,QAAA,OAAOvD,oBAAA,CAAAmD,KAAK,CAAA,CAAA1C,IAAA,CAAL0C,KAAK,EAAKnB,KAAK,IAAIE,oBAAoB,CAACF,KAAK,CAAC,CAAC;AACvD;IAEA,KAAKG,SAAS,YAAYP,OAAO;AAAE,MAAA;AAAA,QAAA,IAAAzB,SAAA;AAClC,QAAA,MAAMsD,QAAQ,GAAGtB,SAAS,CAACuB,QAAQ;AAEnC,QAAA,MAAMC,OAAO,GAAG3D,oBAAA,CAAAG,SAAA,GAAAyD,WAAA,CAAWC,wBAAA,CAAAJ,QAAQ,EAAAhD,IAAA,CAARgD,QAAiB,CAA2C,CAAC,EAAAhD,IAAA,CAAAN,SAAA,EAClF,CAAC,CAAE2D,GAAG,EAAE9B,KAAK,CAAE,KAAK,CAAEE,oBAAoB,CAAC4B,GAAG,CAAC,EAAE5B,oBAAoB,CAACF,KAAK,CAAC,CAAE,CAAC;AAErF,QAAA,OAAO,IAAA+B,IAAA,CAAQJ,OAA6C,CAAC;AAC9D;AAEA,IAAA;AAAS,MAAA;AACR,QAAA,OAAO,IAAI;AACZ;AACA;AACD;AAEO,SAASK,oBAAoBA,CAACC,QAAwB,EAAY;AAAA,EAAA,IAAA7D,SAAA;AACxE,EAAA,QAAQ,IAAI;IACZ,KAAK,OAAO6D,QAAQ,KAAK,SAAS;AAAE,MAAA;QACnC,MAAMC,YAAY,GAAGD,QAAQ;AAE7B,QAAA,OAAOC,YAAY,GAAGhD,QAAQ,GAAGE,SAAS;AAC3C;IAEA,KAAK,OAAO6C,QAAQ,KAAK,QAAQ;AAAE,MAAA;QAClC,MAAME,WAAW,GAAGF,QAAQ;AAE5B,QAAA,OAAO,IAAIzC,UAAU,CAAC2C,WAAW,CAAC;AACnC;IAEA,KAAKpC,QAAQ,CAACkC,QAAQ,CAAC,IAAIG,sBAAA,CAAAhE,SAAA,GAAA,CAAE,OAAO,EAAE,MAAM,CAAE,CAAA,CAAAK,IAAA,CAAAL,SAAA,EAAOM,WAAW,IAAIA,WAAW,IAAIuD,QAAQ,CAAC;AAAE,MAAA;QAC7F,MAAM;UAAEjC,KAAK;AAAEO,UAAAA;AAAK,SAAC,GAAG0B,QAA0B;AAElD,QAAA,OAAO,IAAIzC,UAAU,CAACQ,KAAK,EAAEO,IAAI,CAAC;AACnC;IAEA,KAAK,OAAO0B,QAAQ,KAAK,QAAQ;AAAE,MAAA;QAClC,MAAMI,WAAW,GAAGJ,QAAQ;AAE5B,QAAA,OAAO,IAAIxC,UAAU,CAAC4C,WAAW,CAAC;AACnC;AAEA,IAAA,KAAKtC,QAAQ,CAACkC,QAAQ,CAAC,IAAI,MAAM,IAAIA,QAAQ;AAAE,MAAA;AAC9C,QAAA,MAAM,CAAEtB,GAAG,EAAEC,KAAK,EAAEC,IAAI,EAAEC,KAAK,CAAE,GAAGmB,QAAQ,CAACK,IAAI,EAAc;QAE/D,OAAO,IAAI5C,SAAS,CAAC;UAAEiB,GAAG;UAAEC,KAAK;UAAEC,IAAI;AAAEC,UAAAA;AAAM,SAAC,CAAC;AAClD;IAEA,KAAKyB,cAAA,CAAcN,QAAQ,CAAC;AAAE,MAAA;AAC7B,QAAA,OAAO,IAAItC,QAAQ,CAAC3B,oBAAA,CAAAiE,QAAQ,EAAAxD,IAAA,CAARwD,QAAQ,EAAKjC,KAAK,IAAIgC,oBAAoB,CAAChC,KAAK,CAAC,CAAC,CAAC;AACxE;IAEA,KAAKiC,QAAQ,YAAAF,IAAe;AAAE,MAAA;AAAA,QAAA,IAAA1D,SAAA;QAC7B,MAAMoD,QAAQ,GAAGQ,QAA+C;AAChE,QAAA,MAAMO,OAAO,GAAG,IAAI5C,OAAO,EAAE;AAE7B,QAAA,MAAM6C,SAAS,GAAGzE,oBAAA,CAAAK,SAAA,GAAAuD,WAAA,CAAWC,wBAAA,CAAAJ,QAAQ,CAAA,CAAAhD,IAAA,CAARgD,QAAiB,CAAC,CAAC,CAAAhD,CAAAA,IAAA,CAAAJ,SAAA,EAC1CqE,KAAK,IAAI1E,oBAAA,CAAA0E,KAAK,CAAA,CAAAjE,IAAA,CAALiE,KAAK,EAAKV,oBAAoB,CAAC,CAA2B;QAEzE,KAAK,MAAM,CAAEF,GAAG,EAAE9B,KAAK,CAAE,IAAIyC,SAAS,EAAE;UACvCD,OAAO,CAACd,QAAQ,CAACiB,GAAG,CAACb,GAAG,EAAE9B,KAAK,CAAC;AACjC;AAEA,QAAA,OAAOwC,OAAO;AACf;AAEA,IAAA;AAAS,MAAA;AACR,QAAA,OAAOlD,QAAQ;AAChB;AACA;AACD;;AC5HA;;AASA;AACA,MAAMsD,cAAc,GAAGC,OAAA,CAAO,qCAAqC,CAAC;AAE7D,SAASC,YAAYA,CAACC,UAAkB,EAAkB;AAChE,EAAA,OAAgCC,MAAS,IAAK;IAC7CC,OAAO,CAACC,cAAc,CAACN,cAAc,EAAEG,UAAU,EAAEC,MAAM,CAAC;AAE1D,IAAA,OAAOA,MAAM;GACb;AACF;AAEO,eAAeG,YAAYA,CACjC,GAAGC,aAAkD,EACF;AACnD,EAAA,MAAMC,OAAO,GAAG,MAAMC,QAAA,CAAQC,GAAG,CAChCvF,oBAAA,CAAAoF,aAAa,CAAA,CAAA3E,IAAA,CAAb2E,aAAa,EAAKI,MAAM,IACvBF,QAAA,CAAQG,OAAO,CAACD,MAAM,CAAC,CACrBE,IAAI,CAACF,MAAM,IAAIA,MAAM,CAACG,OAAO,CAC/B,CACF,CAAC;EAED,MAAMhC,OAAO,GAAG3D,oBAAA,CAAAqF,OAAO,CAAA5E,CAAAA,IAAA,CAAP4E,OAAO,EAAKG,MAAM,IAAI;IACrC,MAAMI,SAAS,GAAGX,OAAO,CAACY,WAAW,CAACjB,cAAc,EAAEY,MAAM,CAAW;IAEvE,eAAeM,cAAcA,CAACC,OAAmB,EAAqB;MACrE,MAAMC,IAAI,GAAGhG,oBAAA,CAAA+F,OAAO,CAAAtF,CAAAA,IAAA,CAAPsF,OAAO,EAAK7D,oBAAoB,CAAC;AAC9C,MAAA,MAAM+D,MAAM,GAAG,MAAMC,kBAAA,CAAkBV,MAAM,EAAEQ,IAAI,CAAC,CAACG,OAAO,EAAE;MAE9D,OAAOnC,oBAAoB,CAACiC,MAAM,CAAC;AACpC;AAEA,IAAA,OAAO,CAAEL,SAAS,EAAEE,cAAc,CAAE;AACrC,GAAC,CAAC;EAEF,OAAO/F,mBAAA,CAAmB4D,OAAO,CAAC;AACnC;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cichol/sass-bridge",
-    "version": "4.4.3",
+    "version": "4.6.0",
     "description": "A bridge interface to define Sass custom functions.",
     "homepage": "https://github.com/morrighan/packages",
     "bugs": {
@@ -13,35 +13,39 @@
         "url": "https://www.cichol.com/"
     },
     "type": "module",
-    "main": "releases/cjs.js",
-    "module": "releases/esm.js",
-    "types": "types/index.d.ts",
-    "directories": {
-        "lib": "releases"
-    },
+    "main": "./dists/index.cjs",
+    "module": "./dists/index.js",
+    "types": "./dists/index.d.ts",
     "exports": {
-        "import": "./releases/esm.js",
-        "require": "./releases/cjs.js",
-        "types": "./types/index.d.ts"
+        ".": {
+            "import": {
+                "default": "./dists/index.js",
+                "types": "./dists/index.d.ts"
+            },
+            "require": {
+                "default": "./dists/index.cjs",
+                "types": "./dists/index.d.cts"
+            }
+        },
+        "./package.json": "./package.json"
     },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/morrighan/packages.git",
         "directory": "packages/sass-bridge"
     },
-    "scripts": {
-        "build": "npm run build:tsc",
-        "build:tsc": "npx tsc --project sources --outDir types"
-    },
     "dependencies": {
         "chroma-js": "^3.1.2",
-        "core-js-pure": "^3.38.1",
+        "core-js-pure": "^3.39.0",
         "reflect-metadata": "^0.2.2",
-        "sass": "npm:sass-embedded@^1.77.8"
+        "sass": "npm:sass-embedded@^1.83.0"
+    },
+    "devDependencies": {
+        "@cichol/sass-bridge": "file:."
     },
     "engines": {
-        "node": "^20.18.0",
-        "npm": "^10.9.0"
+        "node": "^20.18.1",
+        "npm": "^11.0.0"
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/",

package/releases/cjs.js

@@ -1,212 +0,0 @@
-'use strict';
-
-var _Symbol = require('core-js-pure/stable/symbol/index.js');
-var _Promise = require('core-js-pure/stable/promise/index.js');
-var _mapInstanceProperty = require('core-js-pure/stable/instance/map.js');
-var _Reflect$construct = require('core-js-pure/stable/reflect/construct.js');
-var _Object$fromEntries = require('core-js-pure/stable/object/from-entries.js');
-require('reflect-metadata');
-var _fillInstanceProperty = require('core-js-pure/stable/instance/fill.js');
-var _Array$from = require('core-js-pure/stable/array/from.js');
-var _entriesInstanceProperty = require('core-js-pure/stable/instance/entries.js');
-var _Map = require('core-js-pure/stable/map/index.js');
-var _everyInstanceProperty = require('core-js-pure/stable/instance/every.js');
-var _Array$isArray = require('core-js-pure/stable/array/is-array.js');
-var chroma = require('chroma-js');
-var _filterInstanceProperty = require('core-js-pure/stable/instance/filter.js');
-var _Object$keys = require('core-js-pure/stable/object/keys.js');
-var _startsWithInstanceProperty = require('core-js-pure/stable/instance/starts-with.js');
-var _Object$getPrototypeOf = require('core-js-pure/stable/object/get-prototype-of.js');
-var sass = require('sass');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var sass__namespace = /*#__PURE__*/_interopNamespaceDefault(sass);
-
-var _context, _context2, _context3, _context4, _context5;
-
-// Type definitions.
-
-const SassTypes = _Object$fromEntries(_mapInstanceProperty(_context = _filterInstanceProperty(_context2 = _filterInstanceProperty(_context3 = _mapInstanceProperty(_context4 = _filterInstanceProperty(_context5 = _Object$keys(sass__namespace)).call(_context5, propertyKey => _startsWithInstanceProperty(propertyKey).call(propertyKey, 'Sass'))).call(_context4, propertyKey => sass__namespace[propertyKey])).call(_context3, constructor => typeof constructor === 'function')).call(_context2, constructor => Object.prototype.isPrototypeOf.call(sass.Value.prototype, constructor.prototype))).call(_context, constructor => [constructor.name, constructor]));
-const SassTRUE = sass__namespace.sassTrue;
-const SassFALSE = sass__namespace.sassFalse;
-const SassNULL = sass__namespace.sassNull;
-const {
-  SassNumber
-} = SassTypes;
-const {
-  SassString
-} = SassTypes;
-const {
-  SassColor
-} = SassTypes;
-const {
-  SassList
-} = SassTypes;
-const {
-  SassMap
-} = SassTypes;
-const SassBoolean = _Object$getPrototypeOf(SassTRUE).constructor;
-
-// Helper functions.
-function isObject(value) {
-  const type = typeof value;
-  return !!value && (type === 'object' || type === 'function');
-}
-function sassToJavaScriptType(sassValue) {
-  switch (true) {
-    case sassValue instanceof SassBoolean:
-      {
-        return sassValue.value;
-      }
-    case sassValue instanceof SassString:
-      {
-        return sassValue.text;
-      }
-    case sassValue instanceof SassNumber:
-      {
-        const {
-          value,
-          numeratorUnits,
-          denominatorUnits
-        } = sassValue;
-        const unit = sassValue.hasUnits ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '') : '';
-        return unit ? {
-          value,
-          unit
-        } : value;
-      }
-    case sassValue instanceof SassColor:
-      {
-        const {
-          red,
-          green,
-          blue,
-          alpha
-        } = sassValue;
-        return chroma(red, green, blue, alpha);
-      }
-    case sassValue instanceof SassList:
-      {
-        var _context;
-        const listValue = sassValue.asList;
-        const length = listValue.size;
-        const array = _fillInstanceProperty(_context = Array(length)).call(_context, undefined);
-        for (let index = 0; index < length; index += 1) {
-          array[index] = listValue.get(index);
-        }
-        return _mapInstanceProperty(array).call(array, value => sassToJavaScriptType(value));
-      }
-    case sassValue instanceof SassMap:
-      {
-        var _context2;
-        const mapValue = sassValue.contents;
-        const entries = _mapInstanceProperty(_context2 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context2, ([key, value]) => [sassToJavaScriptType(key), sassToJavaScriptType(value)]);
-        return new _Map(entries);
-      }
-    default:
-      {
-        return null;
-      }
-  }
-}
-function javaScriptToSassType(rawValue) {
-  var _context3;
-  switch (true) {
-    case typeof rawValue === 'boolean':
-      {
-        const booleanValue = rawValue;
-        return booleanValue ? SassTRUE : SassFALSE;
-      }
-    case typeof rawValue === 'number':
-      {
-        const numberValue = rawValue;
-        return new SassNumber(numberValue);
-      }
-    case isObject(rawValue) && _everyInstanceProperty(_context3 = ['value', 'unit']).call(_context3, propertyKey => propertyKey in rawValue):
-      {
-        const {
-          value,
-          unit
-        } = rawValue;
-        return new SassNumber(value, unit);
-      }
-    case typeof rawValue === 'string':
-      {
-        const stringValue = rawValue;
-        return new SassString(stringValue);
-      }
-    case isObject(rawValue) && '_rgb' in rawValue:
-      {
-        const [red, green, blue, alpha] = rawValue.rgba();
-        return new SassColor({
-          red,
-          green,
-          blue,
-          alpha
-        });
-      }
-    case _Array$isArray(rawValue):
-      {
-        return new SassList(_mapInstanceProperty(rawValue).call(rawValue, value => javaScriptToSassType(value)));
-      }
-    case rawValue instanceof _Map:
-      {
-        var _context4;
-        const mapValue = rawValue;
-        const sassMap = new SassMap();
-        const converted = _mapInstanceProperty(_context4 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context4, entry => _mapInstanceProperty(entry).call(entry, javaScriptToSassType));
-        for (const [key, value] of converted) {
-          sassMap.contents.set(key, value);
-        }
-        return sassMap;
-      }
-    default:
-      {
-        return SassNULL;
-      }
-  }
-}
-
-// Type definitions.
-
-// Constants.
-const KeyOfSignature = _Symbol('@cichol/sass-bridge::KeyOfSignature');
-function sassFunction(definition) {
-  return target => {
-    Reflect.defineMetadata(KeyOfSignature, definition, target);
-    return target;
-  };
-}
-async function getFunctions(...moduleImports) {
-  const modules = await _Promise.all(_mapInstanceProperty(moduleImports).call(moduleImports, module => _Promise.resolve(module).then(module => module.default)));
-  const entries = _mapInstanceProperty(modules).call(modules, module => {
-    const signature = Reflect.getMetadata(KeyOfSignature, module);
-    async function customFunction(rawArgs) {
-      const args = _mapInstanceProperty(rawArgs).call(rawArgs, sassToJavaScriptType);
-      const result = await _Reflect$construct(module, args).execute();
-      return javaScriptToSassType(result);
-    }
-    return [signature, customFunction];
-  });
-  return _Object$fromEntries(entries);
-}
-
-exports.getFunctions = getFunctions;
-exports.sassFunction = sassFunction;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cjs.js","sources":["../sources/types.ts","../sources/type-converter.ts","../sources/index.ts"],"sourcesContent":["// Third-party modules.\nimport type { Color } from 'chroma-js';\nimport * as sass from 'sass';\nimport { Value } from 'sass';\n\n// Type definitions.\nexport type Primitives = boolean | number | string;\n\nexport type NumberWithUnit = { value: number, unit: string };\n\nexport type JavaScriptType<Base = Primitives | Color | NumberWithUnit | null> =\n    | Base\n    | JavaScriptType<Base>[]\n    | Map<JavaScriptType<Base>, JavaScriptType<Base>>;\n\ntype FilterSassPrefix<T extends string> = T extends `Sass${infer R}` ? R : never;\n\ntype SassTypes = Exclude<`Sass${FilterSassPrefix<keyof typeof sass>}`, `Sass${'Boolean' | 'Calculation'}`>;\n\nconst SassTypes = Object.fromEntries(\n    Object.keys(sass)\n        .filter(propertyKey => propertyKey.startsWith('Sass'))\n        .map(propertyKey => sass[propertyKey as SassTypes])\n        .filter(constructor => typeof constructor === 'function')\n        .filter(constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))\n        .map(constructor => [ constructor.name, constructor ] as [SassTypes, (typeof sass)[SassTypes]])\n) as { [P in SassTypes]: (typeof sass)[P] };\n\nexport const SassTRUE = sass.sassTrue;\nexport type SassTRUE = typeof SassTRUE;\n\nexport const SassFALSE = sass.sassFalse;\nexport type SassFALSE = typeof SassFALSE;\n\nexport const SassNULL = sass.sassNull;\nexport type SassNULL = typeof SassNULL;\n\nexport const { SassNumber } = SassTypes;\nexport type SassNumber = InstanceType<typeof SassNumber>;\n\nexport const { SassString } = SassTypes;\nexport type SassString = InstanceType<typeof SassString>;\n\nexport const { SassColor } = SassTypes;\nexport type SassColor = InstanceType<typeof SassColor>;\n\nexport const { SassList } = SassTypes;\nexport type SassList = InstanceType<typeof SassList>;\n\nexport const { SassMap } = SassTypes;\nexport type SassMap = InstanceType<typeof SassMap>;\n\nexport const SassBoolean = Object.getPrototypeOf(SassTRUE).constructor as typeof sass.SassBoolean;\nexport type SassBoolean = sass.SassBoolean;\n\nexport type SassType =\n    | InstanceType<typeof SassTypes extends Record<any, infer R> ? R : never>\n    | SassBoolean;\n","// Third-party modules.\nimport chroma from 'chroma-js';\n\n// Local helpers.\nimport {\n    type SassType,\n    SassBoolean,\n    SassNumber,\n    SassString,\n    SassColor,\n    SassList,\n    SassMap,\n    SassTRUE,\n    SassFALSE,\n    SassNULL,\n    type JavaScriptType,\n    type NumberWithUnit\n} from './types';\n\n// Helper functions.\nfunction isObject(value?: unknown): value is object {\n    const type = typeof value;\n\n    return !!value && (type === 'object' || type === 'function');\n}\n\nexport function sassToJavaScriptType(sassValue: SassType): JavaScriptType {\n    switch (true) {\n    case sassValue instanceof SassBoolean: {\n        return sassValue.value;\n    }\n\n    case sassValue instanceof SassString: {\n        return sassValue.text;\n    }\n\n    case sassValue instanceof SassNumber: {\n        const { value, numeratorUnits, denominatorUnits } = sassValue;\n\n        const unit = sassValue.hasUnits\n            ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '')\n            : '';\n\n        return unit ? { value, unit } : value;\n    }\n\n    case sassValue instanceof SassColor: {\n        const { red, green, blue, alpha } = sassValue;\n\n        return chroma(red, green, blue, alpha);\n    }\n\n    case sassValue instanceof SassList: {\n        const listValue = sassValue.asList;\n        const length = listValue.size;\n        const array = Array(length).fill(undefined) as SassType[];\n\n        for (let index = 0; index < length; index += 1) {\n            array[index] = listValue.get(index) as SassType;\n        }\n\n        return array.map(value => sassToJavaScriptType(value));\n    }\n\n    case sassValue instanceof SassMap: {\n        const mapValue = sassValue.contents;\n\n        const entries = Array.from(mapValue.entries() as IterableIterator<[SassType, SassType]>)\n            .map(([ key, value ]) => [ sassToJavaScriptType(key), sassToJavaScriptType(value) ]);\n\n        return new Map(entries as [JavaScriptType, JavaScriptType][]);\n    }\n\n    default: {\n        return null;\n    }\n    }\n}\n\nexport function javaScriptToSassType(rawValue: JavaScriptType): SassType {\n    switch (true) {\n    case typeof rawValue === 'boolean': {\n        const booleanValue = rawValue;\n\n        return booleanValue ? SassTRUE : SassFALSE;\n    }\n\n    case typeof rawValue === 'number': {\n        const numberValue = rawValue;\n\n        return new SassNumber(numberValue);\n    }\n\n    case isObject(rawValue) && [ 'value', 'unit' ].every(propertyKey => propertyKey in rawValue): {\n        const { value, unit } = rawValue as NumberWithUnit;\n\n        return new SassNumber(value, unit);\n    }\n\n    case typeof rawValue === 'string': {\n        const stringValue = rawValue;\n\n        return new SassString(stringValue);\n    }\n\n    case isObject(rawValue) && '_rgb' in rawValue: {\n        const [ red, green, blue, alpha ] = rawValue.rgba() as number[];\n\n        return new SassColor({ red, green, blue, alpha });\n    }\n\n    case Array.isArray(rawValue): {\n        return new SassList(rawValue.map(value => javaScriptToSassType(value)));\n    }\n\n    case rawValue instanceof Map: {\n        const mapValue = rawValue as Map<JavaScriptType, JavaScriptType>;\n        const sassMap = new SassMap();\n\n        const converted = Array.from(mapValue.entries())\n            .map(entry => entry.map(javaScriptToSassType)) as [SassType, SassType][];\n\n        for (const [ key, value ] of converted) {\n            sassMap.contents.set(key, value);\n        }\n\n        return sassMap;\n    }\n\n    default: {\n        return SassNULL;\n    }\n    }\n}\n","import 'reflect-metadata';\n\n// Third-party modules.\nimport { CustomFunction } from 'sass';\n\n// Local helpers.\nimport type { SassType, JavaScriptType } from './types';\nimport { sassToJavaScriptType, javaScriptToSassType } from './type-converter';\n\n// Type definitions.\nexport interface BridgedFunction {\n    execute(): JavaScriptType | Promise<JavaScriptType>;\n}\n\nexport interface Constructor {\n    new (...args: JavaScriptType[]): BridgedFunction;\n}\n\n// Constants.\nconst KeyOfSignature = Symbol('@cichol/sass-bridge::KeyOfSignature');\n\nexport function sassFunction(definition: string): ClassDecorator {\n    return (<T extends Constructor>(target: T) => {\n        Reflect.defineMetadata(KeyOfSignature, definition, target);\n\n        return target;\n    }) as ClassDecorator;\n}\n\nexport async function getFunctions(\n    ...moduleImports: Promise<{ default: Constructor }>[]\n): Promise<Record<string, CustomFunction<'async'>>> {\n    const modules = await Promise.all(\n        moduleImports.map(module => (\n            Promise.resolve(module)\n                .then(module => module.default)\n        ))\n    );\n\n    const entries = modules.map(module => {\n        const signature = Reflect.getMetadata(KeyOfSignature, module) as string;\n\n        async function customFunction(rawArgs: SassType[]): Promise<SassType> {\n            const args = rawArgs.map(sassToJavaScriptType);\n            const result = await Reflect.construct(module, args).execute();\n\n            return javaScriptToSassType(result);\n        }\n\n        return [ signature, customFunction ] as const;\n    });\n\n    return Object.fromEntries(entries);\n}\n"],"names":["SassTypes","_Object$fromEntries","_mapInstanceProperty","_context","_filterInstanceProperty","_context2","_context3","_context4","_context5","_Object$keys","sass","call","propertyKey","_startsWithInstanceProperty","constructor","Object","prototype","isPrototypeOf","Value","name","SassTRUE","sassTrue","SassFALSE","sassFalse","SassNULL","sassNull","SassNumber","SassString","SassColor","SassList","SassMap","SassBoolean","_Object$getPrototypeOf","isObject","value","type","sassToJavaScriptType","sassValue","text","numeratorUnits","denominatorUnits","unit","hasUnits","join","size","red","green","blue","alpha","chroma","listValue","asList","length","array","_fillInstanceProperty","Array","undefined","index","get","mapValue","contents","entries","_Array$from","_entriesInstanceProperty","key","_Map","javaScriptToSassType","rawValue","booleanValue","numberValue","_everyInstanceProperty","stringValue","rgba","_Array$isArray","sassMap","converted","entry","set","KeyOfSignature","_Symbol","sassFunction","definition","target","Reflect","defineMetadata","getFunctions","moduleImports","modules","_Promise","all","module","resolve","then","default","signature","getMetadata","customFunction","rawArgs","args","result","_Reflect$construct","execute"],"mappings":"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"}

package/releases/esm.js

@@ -1,191 +0,0 @@
-import _Symbol from 'core-js-pure/stable/symbol/index.js';
-import _Promise from 'core-js-pure/stable/promise/index.js';
-import _mapInstanceProperty from 'core-js-pure/stable/instance/map.js';
-import _Reflect$construct from 'core-js-pure/stable/reflect/construct.js';
-import _Object$fromEntries from 'core-js-pure/stable/object/from-entries.js';
-import 'reflect-metadata';
-import _fillInstanceProperty from 'core-js-pure/stable/instance/fill.js';
-import _Array$from from 'core-js-pure/stable/array/from.js';
-import _entriesInstanceProperty from 'core-js-pure/stable/instance/entries.js';
-import _Map from 'core-js-pure/stable/map/index.js';
-import _everyInstanceProperty from 'core-js-pure/stable/instance/every.js';
-import _Array$isArray from 'core-js-pure/stable/array/is-array.js';
-import chroma from 'chroma-js';
-import _filterInstanceProperty from 'core-js-pure/stable/instance/filter.js';
-import _Object$keys from 'core-js-pure/stable/object/keys.js';
-import _startsWithInstanceProperty from 'core-js-pure/stable/instance/starts-with.js';
-import _Object$getPrototypeOf from 'core-js-pure/stable/object/get-prototype-of.js';
-import * as sass from 'sass';
-import { Value } from 'sass';
-
-var _context, _context2, _context3, _context4, _context5;
-
-// Type definitions.
-
-const SassTypes = _Object$fromEntries(_mapInstanceProperty(_context = _filterInstanceProperty(_context2 = _filterInstanceProperty(_context3 = _mapInstanceProperty(_context4 = _filterInstanceProperty(_context5 = _Object$keys(sass)).call(_context5, propertyKey => _startsWithInstanceProperty(propertyKey).call(propertyKey, 'Sass'))).call(_context4, propertyKey => sass[propertyKey])).call(_context3, constructor => typeof constructor === 'function')).call(_context2, constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))).call(_context, constructor => [constructor.name, constructor]));
-const SassTRUE = sass.sassTrue;
-const SassFALSE = sass.sassFalse;
-const SassNULL = sass.sassNull;
-const {
-  SassNumber
-} = SassTypes;
-const {
-  SassString
-} = SassTypes;
-const {
-  SassColor
-} = SassTypes;
-const {
-  SassList
-} = SassTypes;
-const {
-  SassMap
-} = SassTypes;
-const SassBoolean = _Object$getPrototypeOf(SassTRUE).constructor;
-
-// Helper functions.
-function isObject(value) {
-  const type = typeof value;
-  return !!value && (type === 'object' || type === 'function');
-}
-function sassToJavaScriptType(sassValue) {
-  switch (true) {
-    case sassValue instanceof SassBoolean:
-      {
-        return sassValue.value;
-      }
-    case sassValue instanceof SassString:
-      {
-        return sassValue.text;
-      }
-    case sassValue instanceof SassNumber:
-      {
-        const {
-          value,
-          numeratorUnits,
-          denominatorUnits
-        } = sassValue;
-        const unit = sassValue.hasUnits ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '') : '';
-        return unit ? {
-          value,
-          unit
-        } : value;
-      }
-    case sassValue instanceof SassColor:
-      {
-        const {
-          red,
-          green,
-          blue,
-          alpha
-        } = sassValue;
-        return chroma(red, green, blue, alpha);
-      }
-    case sassValue instanceof SassList:
-      {
-        var _context;
-        const listValue = sassValue.asList;
-        const length = listValue.size;
-        const array = _fillInstanceProperty(_context = Array(length)).call(_context, undefined);
-        for (let index = 0; index < length; index += 1) {
-          array[index] = listValue.get(index);
-        }
-        return _mapInstanceProperty(array).call(array, value => sassToJavaScriptType(value));
-      }
-    case sassValue instanceof SassMap:
-      {
-        var _context2;
-        const mapValue = sassValue.contents;
-        const entries = _mapInstanceProperty(_context2 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context2, ([key, value]) => [sassToJavaScriptType(key), sassToJavaScriptType(value)]);
-        return new _Map(entries);
-      }
-    default:
-      {
-        return null;
-      }
-  }
-}
-function javaScriptToSassType(rawValue) {
-  var _context3;
-  switch (true) {
-    case typeof rawValue === 'boolean':
-      {
-        const booleanValue = rawValue;
-        return booleanValue ? SassTRUE : SassFALSE;
-      }
-    case typeof rawValue === 'number':
-      {
-        const numberValue = rawValue;
-        return new SassNumber(numberValue);
-      }
-    case isObject(rawValue) && _everyInstanceProperty(_context3 = ['value', 'unit']).call(_context3, propertyKey => propertyKey in rawValue):
-      {
-        const {
-          value,
-          unit
-        } = rawValue;
-        return new SassNumber(value, unit);
-      }
-    case typeof rawValue === 'string':
-      {
-        const stringValue = rawValue;
-        return new SassString(stringValue);
-      }
-    case isObject(rawValue) && '_rgb' in rawValue:
-      {
-        const [red, green, blue, alpha] = rawValue.rgba();
-        return new SassColor({
-          red,
-          green,
-          blue,
-          alpha
-        });
-      }
-    case _Array$isArray(rawValue):
-      {
-        return new SassList(_mapInstanceProperty(rawValue).call(rawValue, value => javaScriptToSassType(value)));
-      }
-    case rawValue instanceof _Map:
-      {
-        var _context4;
-        const mapValue = rawValue;
-        const sassMap = new SassMap();
-        const converted = _mapInstanceProperty(_context4 = _Array$from(_entriesInstanceProperty(mapValue).call(mapValue))).call(_context4, entry => _mapInstanceProperty(entry).call(entry, javaScriptToSassType));
-        for (const [key, value] of converted) {
-          sassMap.contents.set(key, value);
-        }
-        return sassMap;
-      }
-    default:
-      {
-        return SassNULL;
-      }
-  }
-}
-
-// Type definitions.
-
-// Constants.
-const KeyOfSignature = _Symbol('@cichol/sass-bridge::KeyOfSignature');
-function sassFunction(definition) {
-  return target => {
-    Reflect.defineMetadata(KeyOfSignature, definition, target);
-    return target;
-  };
-}
-async function getFunctions(...moduleImports) {
-  const modules = await _Promise.all(_mapInstanceProperty(moduleImports).call(moduleImports, module => _Promise.resolve(module).then(module => module.default)));
-  const entries = _mapInstanceProperty(modules).call(modules, module => {
-    const signature = Reflect.getMetadata(KeyOfSignature, module);
-    async function customFunction(rawArgs) {
-      const args = _mapInstanceProperty(rawArgs).call(rawArgs, sassToJavaScriptType);
-      const result = await _Reflect$construct(module, args).execute();
-      return javaScriptToSassType(result);
-    }
-    return [signature, customFunction];
-  });
-  return _Object$fromEntries(entries);
-}
-
-export { getFunctions, sassFunction };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esm.js","sources":["../sources/types.ts","../sources/type-converter.ts","../sources/index.ts"],"sourcesContent":["// Third-party modules.\nimport type { Color } from 'chroma-js';\nimport * as sass from 'sass';\nimport { Value } from 'sass';\n\n// Type definitions.\nexport type Primitives = boolean | number | string;\n\nexport type NumberWithUnit = { value: number, unit: string };\n\nexport type JavaScriptType<Base = Primitives | Color | NumberWithUnit | null> =\n    | Base\n    | JavaScriptType<Base>[]\n    | Map<JavaScriptType<Base>, JavaScriptType<Base>>;\n\ntype FilterSassPrefix<T extends string> = T extends `Sass${infer R}` ? R : never;\n\ntype SassTypes = Exclude<`Sass${FilterSassPrefix<keyof typeof sass>}`, `Sass${'Boolean' | 'Calculation'}`>;\n\nconst SassTypes = Object.fromEntries(\n    Object.keys(sass)\n        .filter(propertyKey => propertyKey.startsWith('Sass'))\n        .map(propertyKey => sass[propertyKey as SassTypes])\n        .filter(constructor => typeof constructor === 'function')\n        .filter(constructor => Object.prototype.isPrototypeOf.call(Value.prototype, constructor.prototype))\n        .map(constructor => [ constructor.name, constructor ] as [SassTypes, (typeof sass)[SassTypes]])\n) as { [P in SassTypes]: (typeof sass)[P] };\n\nexport const SassTRUE = sass.sassTrue;\nexport type SassTRUE = typeof SassTRUE;\n\nexport const SassFALSE = sass.sassFalse;\nexport type SassFALSE = typeof SassFALSE;\n\nexport const SassNULL = sass.sassNull;\nexport type SassNULL = typeof SassNULL;\n\nexport const { SassNumber } = SassTypes;\nexport type SassNumber = InstanceType<typeof SassNumber>;\n\nexport const { SassString } = SassTypes;\nexport type SassString = InstanceType<typeof SassString>;\n\nexport const { SassColor } = SassTypes;\nexport type SassColor = InstanceType<typeof SassColor>;\n\nexport const { SassList } = SassTypes;\nexport type SassList = InstanceType<typeof SassList>;\n\nexport const { SassMap } = SassTypes;\nexport type SassMap = InstanceType<typeof SassMap>;\n\nexport const SassBoolean = Object.getPrototypeOf(SassTRUE).constructor as typeof sass.SassBoolean;\nexport type SassBoolean = sass.SassBoolean;\n\nexport type SassType =\n    | InstanceType<typeof SassTypes extends Record<any, infer R> ? R : never>\n    | SassBoolean;\n","// Third-party modules.\nimport chroma from 'chroma-js';\n\n// Local helpers.\nimport {\n    type SassType,\n    SassBoolean,\n    SassNumber,\n    SassString,\n    SassColor,\n    SassList,\n    SassMap,\n    SassTRUE,\n    SassFALSE,\n    SassNULL,\n    type JavaScriptType,\n    type NumberWithUnit\n} from './types';\n\n// Helper functions.\nfunction isObject(value?: unknown): value is object {\n    const type = typeof value;\n\n    return !!value && (type === 'object' || type === 'function');\n}\n\nexport function sassToJavaScriptType(sassValue: SassType): JavaScriptType {\n    switch (true) {\n    case sassValue instanceof SassBoolean: {\n        return sassValue.value;\n    }\n\n    case sassValue instanceof SassString: {\n        return sassValue.text;\n    }\n\n    case sassValue instanceof SassNumber: {\n        const { value, numeratorUnits, denominatorUnits } = sassValue;\n\n        const unit = sassValue.hasUnits\n            ? numeratorUnits.join('*') + (denominatorUnits.size > 0 ? `/${denominatorUnits.join('*')}` : '')\n            : '';\n\n        return unit ? { value, unit } : value;\n    }\n\n    case sassValue instanceof SassColor: {\n        const { red, green, blue, alpha } = sassValue;\n\n        return chroma(red, green, blue, alpha);\n    }\n\n    case sassValue instanceof SassList: {\n        const listValue = sassValue.asList;\n        const length = listValue.size;\n        const array = Array(length).fill(undefined) as SassType[];\n\n        for (let index = 0; index < length; index += 1) {\n            array[index] = listValue.get(index) as SassType;\n        }\n\n        return array.map(value => sassToJavaScriptType(value));\n    }\n\n    case sassValue instanceof SassMap: {\n        const mapValue = sassValue.contents;\n\n        const entries = Array.from(mapValue.entries() as IterableIterator<[SassType, SassType]>)\n            .map(([ key, value ]) => [ sassToJavaScriptType(key), sassToJavaScriptType(value) ]);\n\n        return new Map(entries as [JavaScriptType, JavaScriptType][]);\n    }\n\n    default: {\n        return null;\n    }\n    }\n}\n\nexport function javaScriptToSassType(rawValue: JavaScriptType): SassType {\n    switch (true) {\n    case typeof rawValue === 'boolean': {\n        const booleanValue = rawValue;\n\n        return booleanValue ? SassTRUE : SassFALSE;\n    }\n\n    case typeof rawValue === 'number': {\n        const numberValue = rawValue;\n\n        return new SassNumber(numberValue);\n    }\n\n    case isObject(rawValue) && [ 'value', 'unit' ].every(propertyKey => propertyKey in rawValue): {\n        const { value, unit } = rawValue as NumberWithUnit;\n\n        return new SassNumber(value, unit);\n    }\n\n    case typeof rawValue === 'string': {\n        const stringValue = rawValue;\n\n        return new SassString(stringValue);\n    }\n\n    case isObject(rawValue) && '_rgb' in rawValue: {\n        const [ red, green, blue, alpha ] = rawValue.rgba() as number[];\n\n        return new SassColor({ red, green, blue, alpha });\n    }\n\n    case Array.isArray(rawValue): {\n        return new SassList(rawValue.map(value => javaScriptToSassType(value)));\n    }\n\n    case rawValue instanceof Map: {\n        const mapValue = rawValue as Map<JavaScriptType, JavaScriptType>;\n        const sassMap = new SassMap();\n\n        const converted = Array.from(mapValue.entries())\n            .map(entry => entry.map(javaScriptToSassType)) as [SassType, SassType][];\n\n        for (const [ key, value ] of converted) {\n            sassMap.contents.set(key, value);\n        }\n\n        return sassMap;\n    }\n\n    default: {\n        return SassNULL;\n    }\n    }\n}\n","import 'reflect-metadata';\n\n// Third-party modules.\nimport { CustomFunction } from 'sass';\n\n// Local helpers.\nimport type { SassType, JavaScriptType } from './types';\nimport { sassToJavaScriptType, javaScriptToSassType } from './type-converter';\n\n// Type definitions.\nexport interface BridgedFunction {\n    execute(): JavaScriptType | Promise<JavaScriptType>;\n}\n\nexport interface Constructor {\n    new (...args: JavaScriptType[]): BridgedFunction;\n}\n\n// Constants.\nconst KeyOfSignature = Symbol('@cichol/sass-bridge::KeyOfSignature');\n\nexport function sassFunction(definition: string): ClassDecorator {\n    return (<T extends Constructor>(target: T) => {\n        Reflect.defineMetadata(KeyOfSignature, definition, target);\n\n        return target;\n    }) as ClassDecorator;\n}\n\nexport async function getFunctions(\n    ...moduleImports: Promise<{ default: Constructor }>[]\n): Promise<Record<string, CustomFunction<'async'>>> {\n    const modules = await Promise.all(\n        moduleImports.map(module => (\n            Promise.resolve(module)\n                .then(module => module.default)\n        ))\n    );\n\n    const entries = modules.map(module => {\n        const signature = Reflect.getMetadata(KeyOfSignature, module) as string;\n\n        async function customFunction(rawArgs: SassType[]): Promise<SassType> {\n            const args = rawArgs.map(sassToJavaScriptType);\n            const result = await Reflect.construct(module, args).execute();\n\n            return javaScriptToSassType(result);\n        }\n\n        return [ signature, customFunction ] as const;\n    });\n\n    return Object.fromEntries(entries);\n}\n"],"names":["SassTypes","_Object$fromEntries","_mapInstanceProperty","_context","_filterInstanceProperty","_context2","_context3","_context4","_context5","_Object$keys","sass","call","propertyKey","_startsWithInstanceProperty","constructor","Object","prototype","isPrototypeOf","Value","name","SassTRUE","sassTrue","SassFALSE","sassFalse","SassNULL","sassNull","SassNumber","SassString","SassColor","SassList","SassMap","SassBoolean","_Object$getPrototypeOf","isObject","value","type","sassToJavaScriptType","sassValue","text","numeratorUnits","denominatorUnits","unit","hasUnits","join","size","red","green","blue","alpha","chroma","listValue","asList","length","array","_fillInstanceProperty","Array","undefined","index","get","mapValue","contents","entries","_Array$from","_entriesInstanceProperty","key","_Map","javaScriptToSassType","rawValue","booleanValue","numberValue","_everyInstanceProperty","stringValue","rgba","_Array$isArray","sassMap","converted","entry","set","KeyOfSignature","_Symbol","sassFunction","definition","target","Reflect","defineMetadata","getFunctions","moduleImports","modules","_Promise","all","module","resolve","then","default","signature","getMetadata","customFunction","rawArgs","args","result","_Reflect$construct","execute"],"mappings":"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"}

package/types/index.d.ts

@@ -1,13 +0,0 @@
-import 'reflect-metadata';
-import { CustomFunction } from 'sass';
-import type { JavaScriptType } from './types';
-export interface BridgedFunction {
-    execute(): JavaScriptType | Promise<JavaScriptType>;
-}
-export interface Constructor {
-    new (...args: JavaScriptType[]): BridgedFunction;
-}
-export declare function sassFunction(definition: string): ClassDecorator;
-export declare function getFunctions(...moduleImports: Promise<{
-    default: Constructor;
-}>[]): Promise<Record<string, CustomFunction<'async'>>>;

package/types/type-converter.d.ts

@@ -1,3 +0,0 @@
-import { type SassType, type JavaScriptType } from './types';
-export declare function sassToJavaScriptType(sassValue: SassType): JavaScriptType;
-export declare function javaScriptToSassType(rawValue: JavaScriptType): SassType;

package/types/types.d.ts

@@ -1,31 +0,0 @@
-import type { Color } from 'chroma-js';
-import * as sass from 'sass';
-export type Primitives = boolean | number | string;
-export type NumberWithUnit = {
-    value: number;
-    unit: string;
-};
-export type JavaScriptType<Base = Primitives | Color | NumberWithUnit | null> = Base | JavaScriptType<Base>[] | Map<JavaScriptType<Base>, JavaScriptType<Base>>;
-type FilterSassPrefix<T extends string> = T extends `Sass${infer R}` ? R : never;
-type SassTypes = Exclude<`Sass${FilterSassPrefix<keyof typeof sass>}`, `Sass${'Boolean' | 'Calculation'}`>;
-declare const SassTypes: { [P in SassTypes]: (typeof sass)[P]; };
-export declare const SassTRUE: sass.SassBoolean;
-export type SassTRUE = typeof SassTRUE;
-export declare const SassFALSE: sass.SassBoolean;
-export type SassFALSE = typeof SassFALSE;
-export declare const SassNULL: sass.Value;
-export type SassNULL = typeof SassNULL;
-export declare const SassNumber: typeof sass.SassNumber;
-export type SassNumber = InstanceType<typeof SassNumber>;
-export declare const SassString: typeof sass.SassString;
-export type SassString = InstanceType<typeof SassString>;
-export declare const SassColor: typeof sass.SassColor;
-export type SassColor = InstanceType<typeof SassColor>;
-export declare const SassList: typeof sass.SassList;
-export type SassList = InstanceType<typeof SassList>;
-export declare const SassMap: typeof sass.SassMap;
-export type SassMap = InstanceType<typeof SassMap>;
-export declare const SassBoolean: typeof sass.SassBoolean;
-export type SassBoolean = sass.SassBoolean;
-export type SassType = InstanceType<typeof SassTypes extends Record<any, infer R> ? R : never> | SassBoolean;
-export {};