@embeddables/cli 0.7.13 → 0.7.15

package/dist/compiler/parsePage.d.ts

@@ -1,15 +0,0 @@
-import type { ComponentJson, PageJson } from './types.js';
-export declare function parsePageFromFile(args: {
-    code: string;
-    filePath: string;
-    pageKey: string;
-}): PageJson;
-/**
- * Parses a global component file and returns the components.
- * Similar to parsePageFromFile but simpler - no pageKey needed, just returns components.
- */
-export declare function parseGlobalComponentsFromFile(args: {
-    code: string;
-    filePath: string;
-}): ComponentJson[];
-//# sourceMappingURL=parsePage.d.ts.map

package/dist/compiler/parsePage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parsePage.d.ts","sourceRoot":"","sources":["../../src/compiler/parsePage.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAezD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,QAAQ,CAuHX;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,aAAa,EAAE,CAqGlB"}

package/dist/compiler/parsePage.js

@@ -1,631 +0,0 @@
-import { parse } from '@babel/parser';
-import traverseImport from '@babel/traverse';
-import { ALLOWED_PRIMITIVES, TYPE_MAP, DEFAULTS_BY_TYPE } from './registry.js';
-import { CompileError } from './errors.js';
-import { evalStatic } from './evalStatic.js';
-const traverse = (traverseImport.default ?? traverseImport);
-export function parsePageFromFile(args) {
-    let ast;
-    try {
-        ast = parse(args.code, {
-            sourceType: 'module',
-            plugins: ['typescript', 'jsx'],
-            sourceFilename: args.filePath,
-        });
-    }
-    catch (error) {
-        // Babel parser errors have loc property with line/column
-        const line = error.loc?.line ?? error.loc?.start?.line;
-        const column = error.loc?.column ?? error.loc?.start?.column;
-        throw new CompileError(error.message || 'Syntax error', {
-            file: args.filePath,
-            line,
-            column,
-            pageKey: args.pageKey,
-        });
-    }
-    // collect static consts in module scope + inside page function (v1: module scope only is fine)
-    const constEnv = new Map();
-    traverse(ast, {
-        VariableDeclarator(path) {
-            const id = path.node.id;
-            const init = path.node.init;
-            if (id.type === 'Identifier' && init) {
-                // only accept if init is statically evaluable
-                try {
-                    const v = evalStatic(init, constEnv, args.filePath);
-                    constEnv.set(id.name, v);
-                }
-                catch {
-                    // ignore non-static consts
-                }
-            }
-        },
-    });
-    // find exported function and its return JSX + collect function declarations for custom_validation_function
-    // Supports both default exports (preferred) and named exports
-    let rootJsx = null;
-    let rootFragment = null;
-    const validationFunctionSource = new Map();
-    // Helper to extract JSX from a function body and collect inner function declarations
-    const extractJsxAndFunctions = (fnBody, code) => {
-        const ret = fnBody.body.find((s) => s.type === 'ReturnStatement');
-        const arg = ret?.argument;
-        if (arg) {
-            if (arg.type === 'JSXElement') {
-                rootJsx = arg;
-            }
-            else if (arg.type === 'JSXFragment') {
-                rootFragment = arg;
-            }
-        }
-        for (const stmt of fnBody.body) {
-            if (stmt.type === 'FunctionDeclaration' && stmt.id?.name) {
-                const start = stmt.start ?? 0;
-                const end = stmt.end ?? code.length;
-                validationFunctionSource.set(stmt.id.name, code.slice(start, end));
-            }
-        }
-    };
-    traverse(ast, {
-        // Handle: export default function PageName() { ... }
-        ExportDefaultDeclaration(path) {
-            const decl = path.node.declaration;
-            if (decl.type === 'FunctionDeclaration') {
-                extractJsxAndFunctions(decl.body, args.code);
-            }
-        },
-        // Handle: export function PageName() { ... } (legacy support)
-        ExportNamedDeclaration(path) {
-            const decl = path.node.declaration;
-            if (!decl)
-                return;
-            if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
-                extractJsxAndFunctions(decl.body, args.code);
-            }
-        },
-    });
-    const components = [];
-    if (rootJsx) {
-        // Single root element
-        const tree = jsxToTree(rootJsx, constEnv, args.filePath, validationFunctionSource);
-        flatten(tree, null, components, args.pageKey, args.filePath);
-    }
-    else if (rootFragment) {
-        // Multiple root elements (fragment) - allow empty fragments for blank pages
-        const fragmentChildren = [];
-        const fragment = rootFragment;
-        for (const c of fragment.children) {
-            if (c.type === 'JSXElement') {
-                fragmentChildren.push(c);
-            }
-        }
-        // Allow blank pages - if fragment has no JSXElement children, components array stays empty
-        for (const child of fragmentChildren) {
-            const tree = jsxToTree(child, constEnv, args.filePath, validationFunctionSource);
-            flatten(tree, null, components, args.pageKey, args.filePath);
-        }
-    }
-    else {
-        // Allow blank pages - if no JSX found, components array stays empty
-        // This handles pages that return null, undefined, or have no return statement
-    }
-    return {
-        key: args.pageKey,
-        showNav: true,
-        tags: [],
-        id: `page_${args.pageKey}`,
-        components,
-    };
-}
-/**
- * Parses a global component file and returns the components.
- * Similar to parsePageFromFile but simpler - no pageKey needed, just returns components.
- */
-export function parseGlobalComponentsFromFile(args) {
-    let ast;
-    try {
-        ast = parse(args.code, {
-            sourceType: 'module',
-            plugins: ['typescript', 'jsx'],
-            sourceFilename: args.filePath,
-        });
-    }
-    catch (error) {
-        // Babel parser errors have loc property with line/column
-        const line = error.loc?.line ?? error.loc?.start?.line;
-        const column = error.loc?.column ?? error.loc?.start?.column;
-        throw new CompileError(error.message || 'Syntax error', {
-            file: args.filePath,
-            line,
-            column,
-        });
-    }
-    // collect static consts in module scope
-    const constEnv = new Map();
-    traverse(ast, {
-        VariableDeclarator(path) {
-            const id = path.node.id;
-            const init = path.node.init;
-            if (id.type === 'Identifier' && init) {
-                try {
-                    const v = evalStatic(init, constEnv, args.filePath);
-                    constEnv.set(id.name, v);
-                }
-                catch {
-                    // ignore non-static consts
-                }
-            }
-        },
-    });
-    // find exported function and its return JSX + collect function declarations for custom_validation_function
-    let rootJsx = null;
-    let rootFragment = null;
-    const validationFunctionSource = new Map();
-    const extractJsxAndFunctions = (fnBody, code) => {
-        const ret = fnBody.body.find((s) => s.type === 'ReturnStatement');
-        const arg = ret?.argument;
-        if (arg) {
-            if (arg.type === 'JSXElement') {
-                rootJsx = arg;
-            }
-            else if (arg.type === 'JSXFragment') {
-                rootFragment = arg;
-            }
-        }
-        for (const stmt of fnBody.body) {
-            if (stmt.type === 'FunctionDeclaration' && stmt.id?.name) {
-                const start = stmt.start ?? 0;
-                const end = stmt.end ?? code.length;
-                validationFunctionSource.set(stmt.id.name, code.slice(start, end));
-            }
-        }
-    };
-    traverse(ast, {
-        ExportDefaultDeclaration(path) {
-            const decl = path.node.declaration;
-            if (decl.type === 'FunctionDeclaration') {
-                extractJsxAndFunctions(decl.body, args.code);
-            }
-        },
-        ExportNamedDeclaration(path) {
-            const decl = path.node.declaration;
-            if (!decl)
-                return;
-            if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
-                extractJsxAndFunctions(decl.body, args.code);
-            }
-        },
-    });
-    const components = [];
-    if (rootJsx) {
-        const tree = jsxToTree(rootJsx, constEnv, args.filePath, validationFunctionSource);
-        flatten(tree, null, components, '', args.filePath);
-    }
-    else if (rootFragment) {
-        const fragmentChildren = [];
-        const fragment = rootFragment;
-        for (const c of fragment.children) {
-            if (c.type === 'JSXElement') {
-                fragmentChildren.push(c);
-            }
-        }
-        for (const child of fragmentChildren) {
-            const tree = jsxToTree(child, constEnv, args.filePath, validationFunctionSource);
-            flatten(tree, null, components, '', args.filePath);
-        }
-    }
-    return components;
-}
-function jsxToTree(el, constEnv, filePath, validationFunctionSource) {
-    const opening = el.openingElement;
-    const tagName = getJsxTagName(opening.name);
-    if (!ALLOWED_PRIMITIVES.has(tagName)) {
-        throw new CompileError(`Unknown/unsupported primitive <${tagName}>.`, loc(filePath, opening));
-    }
-    const jsonType = TYPE_MAP[tagName];
-    const attrs = attrsToProps(opening.attributes, constEnv, filePath, validationFunctionSource);
-    const id = requireString(attrs, 'id', filePath, opening);
-    const key = requireString(attrs, 'key', filePath, opening);
-    const tags = (attrs.tags ?? []);
-    if (!Array.isArray(tags) || tags.some((t) => typeof t !== 'string')) {
-        throw new CompileError(`Prop "tags" must be an array of strings.`, loc(filePath, opening));
-    }
-    delete attrs.id;
-    delete attrs.key;
-    delete attrs.tags;
-    // For CustomHTML, convert all children (including text) to HTML string
-    if (tagName === 'CustomHTML') {
-        // Check if there are any children (including text nodes and fragments)
-        const hasChildren = el.children.some((c) => c.type === 'JSXElement' ||
-            c.type === 'JSXFragment' ||
-            (c.type === 'JSXText' && c.value.trim().length > 0) ||
-            c.type === 'JSXExpressionContainer');
-        if (hasChildren) {
-            // Convert JSX children to HTML string
-            const htmlString = jsxChildrenToHTML(el.children, constEnv, filePath);
-            attrs.text = htmlString;
-        }
-        // Return with empty children array since we've converted them to HTML
-        return {
-            tag: tagName,
-            type: jsonType,
-            id,
-            key,
-            tags,
-            props: attrs,
-            children: [],
-            loc: loc(filePath, opening),
-        };
-    }
-    // children JSXElements only (ignore whitespace text nodes)
-    const children = el.children
-        .filter((c) => c.type === 'JSXElement')
-        .map((c) => jsxToTree(c, constEnv, filePath, validationFunctionSource));
-    // v1 rule: only Container can have children (CustomHTML handled above)
-    if (children.length > 0 && tagName !== 'Container') {
-        throw new CompileError(`<${tagName}> cannot have children. Only <Container> and <CustomHTML> may contain children.`, loc(filePath, opening));
-    }
-    // enforce OptionSelector uses buttons
-    if (tagName === 'OptionSelector' && 'options' in attrs) {
-        throw new CompileError(`OptionSelector does not support prop "options". Use "buttons".`, loc(filePath, opening));
-    }
-    return {
-        tag: tagName,
-        type: jsonType,
-        id,
-        key,
-        tags,
-        props: attrs,
-        children,
-        loc: loc(filePath, opening),
-    };
-}
-function flatten(node, parentId, out, pageKey, filePath) {
-    const base = {
-        type: node.type,
-        id: node.id,
-        key: node.key,
-        tags: node.tags,
-    };
-    if (parentId)
-        base.parent_id = parentId;
-    const defaults = DEFAULTS_BY_TYPE[node.type] ?? {};
-    // Extract extra props from props={...} (round-trip from reverse compiler) and merge into component
-    const { props: extraProps, ...restProps } = node.props;
-    const mergedExtra = extraProps != null && typeof extraProps === 'object' && !Array.isArray(extraProps)
-        ? extraProps
-        : {};
-    const json = {
-        ...base,
-        ...defaults,
-        ...restProps,
-        ...mergedExtra,
-    };
-    // Helper to create errors with component context
-    const createError = (message, loc) => {
-        return new CompileError(message, {
-            ...loc,
-            pageKey,
-            componentId: node.id,
-            componentKey: node.key,
-        });
-    };
-    // Normalize OptionSelector buttons: generate IDs + defaults
-    if (json.type === 'OptionSelector') {
-        const buttons = json.buttons;
-        if (buttons != null) {
-            if (!Array.isArray(buttons)) {
-                throw createError(`OptionSelector requires "buttons" as an array. Got: ${typeof buttons}`, node.loc);
-            }
-            json.buttons = buttons.map((b) => {
-                if (!b || typeof b !== 'object') {
-                    throw createError(`Each button must be an object.`, node.loc);
-                }
-                // key can be string or null, text is optional
-                if (b.key !== null && typeof b.key !== 'string') {
-                    throw createError(`Each button requires "key" to be a string or null. Got: ${typeof b.key}`, node.loc);
-                }
-                if (b.text != null && typeof b.text !== 'string') {
-                    throw createError(`Button "text" must be a string if provided. Got: ${typeof b.text}`, node.loc);
-                }
-                // Preserve all OptionSelectorButton properties from the input
-                // Required properties
-                const result = {
-                    id: typeof b.id === 'string' ? b.id : `option_${b.key}`,
-                    key: b.key,
-                };
-                // Optional properties - only include if present
-                if (b.text != null)
-                    result.text = b.text;
-                if (b.description != null)
-                    result.description = b.description;
-                // triggerEvent defaults to 'no-action' if not provided
-                result.triggerEvent = typeof b.triggerEvent === 'string' ? b.triggerEvent : 'no-action';
-                if (b.conditions != null)
-                    result.conditions = b.conditions;
-                if (b.openUrlInNewTab != null)
-                    result.openUrlInNewTab = b.openUrlInNewTab;
-                if (b.url != null)
-                    result.url = b.url;
-                if (b.single_select != null)
-                    result.single_select = b.single_select;
-                if (b.icon != null)
-                    result.icon = b.icon;
-                if (b.emojiIcon != null)
-                    result.emojiIcon = b.emojiIcon;
-                if (b.imageUrl != null)
-                    result.imageUrl = b.imageUrl;
-                if (b.imageAltText != null)
-                    result.imageAltText = b.imageAltText;
-                if (b.hide != null)
-                    result.hide = b.hide;
-                if (b.is_repeatable_button != null)
-                    result.is_repeatable_button = b.is_repeatable_button;
-                return result;
-            });
-        }
-        // If buttons is null/undefined, leave it as is (optional prop)
-    }
-    out.push(json);
-    for (const child of node.children) {
-        flatten(child, node.id, out, pageKey, filePath);
-    }
-}
-/**
- * Normalize validation function source for embeddable.json: use name "validate" and strip TS (param types).
- */
-function normalizeValidationFunctionSource(source) {
-    // 1. Rename function to "validate"
-    let out = source.replace(/function\s+\w+\s*\(/, 'function validate(');
-    // 2. Strip parameter type annotations in the first parameter list (e.g. value: string -> value)
-    const openParen = out.indexOf('(', out.indexOf('function'));
-    if (openParen !== -1) {
-        let depth = 1;
-        let i = openParen + 1;
-        while (depth > 0 && i < out.length) {
-            if (out[i] === '(')
-                depth++;
-            else if (out[i] === ')')
-                depth--;
-            i++;
-        }
-        const params = out.slice(openParen, i);
-        const paramsNoTypes = params.replace(/:\s*[^,)]+/g, '');
-        out = out.slice(0, openParen) + paramsNoTypes + out.slice(i);
-    }
-    return out;
-}
-function attrsToProps(attrs, constEnv, filePath, validationFunctionSource) {
-    const out = {};
-    for (const a of attrs) {
-        if (a.type === 'JSXSpreadAttribute') {
-            throw new CompileError('JSX spread props are not supported.', loc(filePath, a));
-        }
-        const name = a.name.type === 'JSXIdentifier' ? a.name.name : `${a.name.namespace.name}:${a.name.name.name}`;
-        if (!a.value) {
-            // <X disabled />
-            out[name] = true;
-            continue;
-        }
-        if (a.value.type === 'StringLiteral') {
-            out[name] = a.value.value;
-            continue;
-        }
-        if (a.value.type === 'JSXExpressionContainer') {
-            const expr = a.value.expression;
-            // custom_validation_function: resolve to source and normalize to "validate" + JS for embeddable.json
-            if (name === 'custom_validation_function' &&
-                expr.type === 'Identifier' &&
-                validationFunctionSource?.has(expr.name)) {
-                out[name] = normalizeValidationFunctionSource(validationFunctionSource.get(expr.name));
-                continue;
-            }
-            out[name] = evalStatic(expr, constEnv, filePath);
-            continue;
-        }
-        throw new CompileError(`Unsupported JSX attribute value for "${name}".`, loc(filePath, a));
-    }
-    // When validation_formula is not "custom", custom_validation_function is ignored and omitted (removed on save).
-    if (out.validation_formula != null && out.validation_formula !== 'custom' && 'custom_validation_function' in out) {
-        delete out.custom_validation_function;
-    }
-    return out;
-}
-function getJsxTagName(n) {
-    if (n.type === 'JSXIdentifier')
-        return n.name;
-    throw new CompileError('Only simple JSX identifiers are supported (no member expressions).');
-}
-function requireString(obj, prop, filePath, node) {
-    const v = obj[prop];
-    if (typeof v !== 'string' || v.length === 0) {
-        throw new CompileError(`Missing required string prop "${prop}".`, loc(filePath, node));
-    }
-    return v;
-}
-function loc(file, node) {
-    return { file, line: node.loc?.start?.line, column: node.loc?.start?.column };
-}
-/**
- * Converts JSX children to HTML string.
- * Handles JSXElements, JSXText, JSXExpressions, and JSXFragments.
- * @param preserveWhitespace If true, preserves all whitespace (for <style> and <script> tags)
- */
-function jsxChildrenToHTML(children, constEnv, filePath, preserveWhitespace = false) {
-    let html = '';
-    for (const child of children) {
-        if (child.type === 'JSXElement') {
-            html += jsxElementToHTML(child, constEnv, filePath);
-        }
-        else if (child.type === 'JSXText') {
-            const text = child.value;
-            // For <style> and <script> tags, preserve all whitespace
-            // For other tags, skip whitespace-only text (it's likely indentation)
-            if (preserveWhitespace || text.trim().length > 0) {
-                html += escapeHTML(text);
-            }
-        }
-        else if (child.type === 'JSXExpressionContainer') {
-            // Try to evaluate static expressions
-            try {
-                const value = evalStatic(child.expression, constEnv, filePath);
-                if (typeof value === 'string') {
-                    html += escapeHTML(value);
-                }
-                else if (value != null) {
-                    html += escapeHTML(String(value));
-                }
-            }
-            catch {
-                throw new CompileError('CustomHTML children must be static. Dynamic expressions are not supported.', loc(filePath, child));
-            }
-        }
-        else if (child.type === 'JSXFragment') {
-            // Handle fragments by recursively processing their children
-            html += jsxChildrenToHTML(child.children, constEnv, filePath, preserveWhitespace);
-        }
-        // Ignore JSXSpreadChild and other unsupported types
-    }
-    return html;
-}
-/**
- * HTML5 void elements - these are the only elements that can be self-closing in HTML.
- * For all other elements, we must emit explicit closing tags even if they're self-closing in JSX.
- * See: https://html.spec.whatwg.org/multipage/syntax.html#void-elements
- */
-const HTML_VOID_ELEMENTS = new Set([
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-]);
-/**
- * Map React/JSX attribute names to HTML attribute names so serialized HTML
- * uses valid attributes (e.g. class for CSS, not className).
- */
-function jsxAttrNameToHTMLAttrName(jsxName) {
-    switch (jsxName) {
-        case 'className':
-            return 'class';
-        case 'htmlFor':
-            return 'for';
-        case 'tabIndex':
-            return 'tabindex';
-        default:
-            return jsxName;
-    }
-}
-/**
- * Converts a JSX element to HTML string.
- */
-function jsxElementToHTML(el, constEnv, filePath) {
-    const opening = el.openingElement;
-    const tagName = getJsxTagName(opening.name);
-    // Build attributes string (use HTML attribute names so class selectors work)
-    const attrs = [];
-    for (const attr of opening.attributes) {
-        if (attr.type === 'JSXAttribute') {
-            const name = attr.name.type === 'JSXIdentifier'
-                ? attr.name.name
-                : `${attr.name.namespace.name}:${attr.name.name.name}`;
-            const htmlName = jsxAttrNameToHTMLAttrName(name);
-            if (!attr.value) {
-                // Boolean attribute
-                attrs.push(htmlName);
-            }
-            else if (attr.value.type === 'StringLiteral') {
-                attrs.push(`${htmlName}="${escapeHTMLAttribute(attr.value.value)}"`);
-            }
-            else if (attr.value.type === 'JSXExpressionContainer') {
-                try {
-                    const value = evalStatic(attr.value.expression, constEnv, filePath);
-                    if (name === 'style' && typeof value === 'object' && value !== null) {
-                        // Convert style object to CSS string
-                        const cssString = styleObjectToCSS(value);
-                        attrs.push(`${htmlName}="${escapeHTMLAttribute(cssString)}"`);
-                    }
-                    else if (typeof value === 'string') {
-                        attrs.push(`${htmlName}="${escapeHTMLAttribute(value)}"`);
-                    }
-                    else if (typeof value === 'number' || typeof value === 'boolean') {
-                        attrs.push(`${htmlName}="${String(value)}"`);
-                    }
-                }
-                catch {
-                    throw new CompileError('CustomHTML attribute values must be static. Dynamic expressions are not supported.', loc(filePath, attr));
-                }
-            }
-        }
-    }
-    const attrsStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
-    // For <style> and <script> tags, preserve all whitespace to maintain CSS/JS formatting
-    const isRawTextTag = tagName.toLowerCase() === 'style' || tagName.toLowerCase() === 'script';
-    const childrenHTML = jsxChildrenToHTML(el.children, constEnv, filePath, isRawTextTag);
-    if (el.closingElement) {
-        return `<${tagName}${attrsStr}>${childrenHTML}</${tagName}>`;
-    }
-    else {
-        // Self-closing in JSX - check if it's an HTML void element
-        const isVoidElement = HTML_VOID_ELEMENTS.has(tagName.toLowerCase());
-        if (isVoidElement) {
-            // Void elements can be self-closing in HTML
-            return `<${tagName}${attrsStr} />`;
-        }
-        else {
-            // Non-void elements MUST have explicit closing tags in HTML
-            // Otherwise browsers interpret <div /> as <div> (unclosed)
-            return `<${tagName}${attrsStr}></${tagName}>`;
-        }
-    }
-}
-/**
- * Escapes HTML entities in text content.
- */
-function escapeHTML(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
-}
-/**
- * Escapes HTML entities in attribute values.
- */
-function escapeHTMLAttribute(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
-/**
- * Converts a JSX style object to CSS string.
- * Example: { margin: 0, padding: 0, color: "#171717" } -> "margin: 0; padding: 0; color: #171717;"
- */
-function styleObjectToCSS(styleObj) {
-    const cssParts = [];
-    for (const [key, value] of Object.entries(styleObj)) {
-        // Preserve CSS custom properties (e.g., --ta, --my-variable) as-is
-        if (key.startsWith('--')) {
-            cssParts.push(`${key}: ${value};`);
-        }
-        else {
-            // Convert camelCase to kebab-case (e.g., lineHeight -> line-height)
-            const cssKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
-            cssParts.push(`${cssKey}: ${value};`);
-        }
-    }
-    return cssParts.join(' ');
-}

package/dist/compiler/registry.d.ts

@@ -1,4 +0,0 @@
-export declare const ALLOWED_PRIMITIVES: Set<string>;
-export declare const TYPE_MAP: Record<string, string>;
-export declare const DEFAULTS_BY_TYPE: Record<string, Record<string, any>>;
-//# sourceMappingURL=registry.d.ts.map

package/dist/compiler/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/compiler/registry.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,aAoB7B,CAAA;AAGF,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoB3C,CAAA;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM,CAAA"}