@fractaldesign/pop 0.0.0-stage → 0.1.0

package/dist/lang.js

@@ -0,0 +1,345 @@
+import { config as config$1 } from './lang/typescript.js';
+import { config } from './lang/plaintext.js';
+
+/** Mutable registry that maps a canonical language id to its parse config. */ const configRegistry = new Map();
+function registerLanguageConfig(id, config) {
+    configRegistry.set(id, config);
+}
+function getLanguageConfig(id) {
+    return configRegistry.get(id);
+}
+function resetLanguageConfigRegistry() {
+    configRegistry.clear();
+}
+
+const languageRegistry = new Map();
+function normalizeLanguageName(value) {
+    return value.trim().toLowerCase().replace(/^\./, '');
+}
+function registerName(name, language) {
+    const normalized = normalizeLanguageName(name);
+    if (!normalized) return;
+    const existing = languageRegistry.get(normalized);
+    if (existing && existing.id !== language.id) {
+        throw new Error(`Language name "${normalized}" is shared by "${existing.id}" and "${language.id}"`);
+    }
+    languageRegistry.set(normalized, language);
+}
+function registerLanguage(language, config) {
+    const names = new Set([
+        language.id,
+        language.extension,
+        ...language.aliases
+    ]);
+    for (const name of names){
+        registerName(name, language);
+    }
+    if (config) {
+        registerLanguageConfig(language.id, config);
+    }
+}
+function setDefaults(input) {
+    resetLanguageRegistry();
+    resetLanguageConfigRegistry();
+    if (Array.isArray(input)) {
+        for (const language of input){
+            registerLanguage(language);
+        }
+    } else {
+        for (const [id, config] of Object.entries(input)){
+            const language = allLanguages.find((l)=>l.id === id);
+            if (language) {
+                registerLanguage(language, config);
+            } else {
+                registerLanguage({
+                    id,
+                    extension: id,
+                    aliases: []
+                }, config);
+            }
+        }
+    }
+}
+const configImporters = {
+    javascript: ()=>import('./lang/javascript.js'),
+    typescript: ()=>import('./lang/typescript.js'),
+    css: ()=>import('./lang/css.js'),
+    scss: ()=>import('./lang/scss.js'),
+    sass: ()=>import('./lang/sass.js'),
+    html: ()=>import('./lang/html.js'),
+    svelte: ()=>import('./lang/svelte.js'),
+    markdown: ()=>import('./lang/markdown.js'),
+    diff: ()=>import('./lang/diff.js'),
+    plaintext: ()=>import('./lang/plaintext.js'),
+    c: ()=>import('./lang/c.js'),
+    cpp: ()=>import('./lang/cpp.js'),
+    csharp: ()=>import('./lang/csharp.js'),
+    dockerfile: ()=>import('./lang/dockerfile.js'),
+    go: ()=>import('./lang/go.js'),
+    graphql: ()=>import('./lang/graphql.js'),
+    hcl: ()=>import('./lang/hcl.js'),
+    java: ()=>import('./lang/java.js'),
+    json: ()=>import('./lang/json.js'),
+    kotlin: ()=>import('./lang/kotlin.js'),
+    lua: ()=>import('./lang/lua.js'),
+    php: ()=>import('./lang/php.js'),
+    powershell: ()=>import('./lang/powershell.js'),
+    python: ()=>import('./lang/python.js'),
+    ruby: ()=>import('./lang/ruby.js'),
+    rust: ()=>import('./lang/rust.js'),
+    shell: ()=>import('./lang/shell.js'),
+    sql: ()=>import('./lang/sql.js'),
+    swift: ()=>import('./lang/swift.js'),
+    toml: ()=>import('./lang/toml.js'),
+    yaml: ()=>import('./lang/yaml.js'),
+    zig: ()=>import('./lang/zig.js')
+};
+async function importDefaults(ids) {
+    await Promise.all(ids.map(async (id)=>{
+        const importer = configImporters[id];
+        if (!importer) return;
+        const { config } = await importer();
+        const language = allLanguages.find((l)=>l.id === id);
+        if (language) {
+            registerLanguage(language, config);
+        } else {
+            registerLanguage({
+                id,
+                extension: id,
+                aliases: []
+            }, config);
+        }
+    }));
+}
+/** Find canonical language metadata by name, alias, or extension. */ function findLanguage(name) {
+    if (typeof name !== 'string') return undefined;
+    return languageRegistry.get(normalizeLanguageName(name));
+}
+/** Resolve a name/alias/extension to its canonical language id. */ function lang(name) {
+    return findLanguage(name)?.id;
+}
+/** Alias for {@link lang}. */ const canonicalizeLang = lang;
+function getRegisteredLanguages() {
+    return [
+        ...new Set(languageRegistry.values())
+    ];
+}
+function resetLanguageRegistry() {
+    languageRegistry.clear();
+}
+const allLanguages = [
+    {
+        id: 'javascript',
+        extension: 'js',
+        aliases: [
+            'jsx',
+            'node'
+        ]
+    },
+    {
+        id: 'typescript',
+        extension: 'ts',
+        aliases: [
+            'tsx'
+        ]
+    },
+    {
+        id: 'css',
+        extension: 'css',
+        aliases: []
+    },
+    {
+        id: 'scss',
+        extension: 'scss',
+        aliases: []
+    },
+    {
+        id: 'sass',
+        extension: 'sass',
+        aliases: [
+            'indented-sass'
+        ]
+    },
+    {
+        id: 'html',
+        extension: 'html',
+        aliases: [
+            'htm',
+            'xml'
+        ]
+    },
+    {
+        id: 'svelte',
+        extension: 'svelte',
+        aliases: []
+    },
+    {
+        id: 'markdown',
+        extension: 'md',
+        aliases: [
+            'md',
+            'mdx',
+            'svx'
+        ]
+    },
+    {
+        id: 'diff',
+        extension: 'diff',
+        aliases: [
+            'patch'
+        ]
+    },
+    {
+        id: 'plaintext',
+        extension: 'txt',
+        aliases: [
+            'text',
+            'plain'
+        ]
+    },
+    {
+        id: 'c',
+        extension: 'c',
+        aliases: []
+    },
+    {
+        id: 'cpp',
+        extension: 'cpp',
+        aliases: [
+            'c++',
+            'cc',
+            'cxx'
+        ]
+    },
+    {
+        id: 'csharp',
+        extension: 'cs',
+        aliases: [
+            'c#',
+            'dotnet'
+        ]
+    },
+    {
+        id: 'dockerfile',
+        extension: 'dockerfile',
+        aliases: [
+            'docker'
+        ]
+    },
+    {
+        id: 'go',
+        extension: 'go',
+        aliases: [
+            'golang'
+        ]
+    },
+    {
+        id: 'graphql',
+        extension: 'graphql',
+        aliases: [
+            'gql'
+        ]
+    },
+    {
+        id: 'hcl',
+        extension: 'hcl',
+        aliases: [
+            'terraform',
+            'tf'
+        ]
+    },
+    {
+        id: 'java',
+        extension: 'java',
+        aliases: []
+    },
+    {
+        id: 'json',
+        extension: 'json',
+        aliases: [
+            'jsonc'
+        ]
+    },
+    {
+        id: 'kotlin',
+        extension: 'kt',
+        aliases: [
+            'kts'
+        ]
+    },
+    {
+        id: 'lua',
+        extension: 'lua',
+        aliases: []
+    },
+    {
+        id: 'php',
+        extension: 'php',
+        aliases: []
+    },
+    {
+        id: 'powershell',
+        extension: 'ps1',
+        aliases: [
+            'pwsh'
+        ]
+    },
+    {
+        id: 'python',
+        extension: 'py',
+        aliases: [
+            'python3'
+        ]
+    },
+    {
+        id: 'ruby',
+        extension: 'rb',
+        aliases: []
+    },
+    {
+        id: 'rust',
+        extension: 'rs',
+        aliases: []
+    },
+    {
+        id: 'shell',
+        extension: 'sh',
+        aliases: [
+            'bash',
+            'zsh'
+        ]
+    },
+    {
+        id: 'sql',
+        extension: 'sql',
+        aliases: []
+    },
+    {
+        id: 'swift',
+        extension: 'swift',
+        aliases: []
+    },
+    {
+        id: 'toml',
+        extension: 'toml',
+        aliases: []
+    },
+    {
+        id: 'yaml',
+        extension: 'yaml',
+        aliases: [
+            'yml'
+        ]
+    },
+    {
+        id: 'zig',
+        extension: 'zig',
+        aliases: []
+    }
+];
+setDefaults({
+    typescript: config$1,
+    plaintext: config
+});
+
+export { allLanguages, canonicalizeLang, findLanguage, getLanguageConfig, getRegisteredLanguages, importDefaults, lang, registerLanguage, resetLanguageRegistry, setDefaults };

package/dist/theme.d.ts

@@ -0,0 +1,102 @@
+/**
+ * fractalpop core — token model, line assembly, and rendering.
+ *
+ * Design: tokens are numeric `[type, value]` pairs during lexing (fast Set/array
+ * work); the string type names are resolved only at render. Output is an HTML
+ * string with no DOM required — so SSR and client produce identical markup.
+ */
+/** The stable, ordered token-type list. This list is the theming contract:
+ * each type maps to one CSS variable `--fp-<type>` and one class `fp__token--<type>`. */
+declare const TokenTypes: readonly ["identifier", "keyword", "string", "class", "property", "entity", "jsxliterals", "sign", "comment", "break", "space"];
+type TokenType = (typeof TokenTypes)[number];
+
+/**
+ * fractalpop theme system — token palette mappings and default themes.
+ *
+ * A theme is either a single ThemePalette, or a composite { light, dark } pair
+ * rendered with CSS light-dark().
+ */
+
+type ThemeToken = Exclude<TokenType, 'break' | 'space'>;
+type ThemePalette = Readonly<{
+    background: string;
+    foreground: string;
+    caret?: string;
+    title?: string;
+    control?: string;
+    lineNumber?: string;
+    lineHighlight?: string;
+} & Partial<Record<ThemeToken, string>>>;
+type Theme = ThemePalette | Readonly<{
+    light: ThemePalette;
+    dark: ThemePalette;
+}>;
+declare const tokenKeys: readonly ThemeToken[];
+/** Convert a ThemePalette into a dictionary of CSS property declarations. */
+declare function paletteVars(p: ThemePalette): Record<string, string>;
+/** Return an inline `style` string of theme variables, or '' when no theme is given. */
+declare function themeStyle(theme: Theme | undefined): string;
+/** Emit a copyable CSS block of --fp-* variables for a given selector. */
+declare function themeCss(selector: string, theme: Theme): string;
+/** SvelteKit theme (Light) */
+declare const sveltekitLight: ThemePalette;
+/** SvelteKit theme (Dark) */
+declare const sveltekitDark: ThemePalette;
+/** SvelteKit theme (adaptive light/dark via CSS light-dark()) */
+declare const sveltekit: Theme;
+/** VS Code theme (Light) */
+declare const vscodeLight: ThemePalette;
+/** VS Code theme (Dark) */
+declare const vscodeDark: ThemePalette;
+/** VS Code theme (adaptive light/dark via CSS light-dark()) */
+declare const vscode: Theme;
+/** Shipped default themes bundle */
+declare const themes: {
+    readonly sveltekit: Readonly<{
+        light: ThemePalette;
+        dark: ThemePalette;
+    }>;
+    readonly sveltekitLight: Readonly<{
+        background: string;
+        foreground: string;
+        caret?: string;
+        title?: string;
+        control?: string;
+        lineNumber?: string;
+        lineHighlight?: string;
+    } & Partial<Record<ThemeToken, string>>>;
+    readonly sveltekitDark: Readonly<{
+        background: string;
+        foreground: string;
+        caret?: string;
+        title?: string;
+        control?: string;
+        lineNumber?: string;
+        lineHighlight?: string;
+    } & Partial<Record<ThemeToken, string>>>;
+    readonly vscode: Readonly<{
+        light: ThemePalette;
+        dark: ThemePalette;
+    }>;
+    readonly vscodeLight: Readonly<{
+        background: string;
+        foreground: string;
+        caret?: string;
+        title?: string;
+        control?: string;
+        lineNumber?: string;
+        lineHighlight?: string;
+    } & Partial<Record<ThemeToken, string>>>;
+    readonly vscodeDark: Readonly<{
+        background: string;
+        foreground: string;
+        caret?: string;
+        title?: string;
+        control?: string;
+        lineNumber?: string;
+        lineHighlight?: string;
+    } & Partial<Record<ThemeToken, string>>>;
+};
+
+export { paletteVars, sveltekit, sveltekitDark, sveltekitLight, themeCss, themeStyle, themes, tokenKeys, vscode, vscodeDark, vscodeLight };
+export type { Theme, ThemePalette, ThemeToken };

package/dist/theme.js

@@ -0,0 +1,132 @@
+/**
+ * fractalpop theme system — token palette mappings and default themes.
+ *
+ * A theme is either a single ThemePalette, or a composite { light, dark } pair
+ * rendered with CSS light-dark().
+ */ const tokenKeys = [
+    'identifier',
+    'keyword',
+    'string',
+    'class',
+    'property',
+    'entity',
+    'jsxliterals',
+    'sign',
+    'comment'
+];
+const lightDark = (light, dark)=>`light-dark(${light}, ${dark})`;
+/** Convert a ThemePalette into a dictionary of CSS property declarations. */ function paletteVars(p) {
+    const v = {
+        'background-color': p.background,
+        color: p.foreground,
+        '--fp-caret-color': p.caret ?? p.foreground,
+        '--fp-title-color': p.title ?? p.foreground,
+        '--fp-control-color': p.control ?? p.comment ?? p.foreground,
+        '--fp-line-number-color': p.lineNumber ?? p.comment ?? p.foreground,
+        '--fp-line-highlight-color': p.lineHighlight ?? 'color-mix(in srgb, currentColor 12%, transparent)'
+    };
+    for (const t of tokenKeys)v[`--fp-${t}`] = p[t] ?? p.foreground;
+    return v;
+}
+function toCss(vars) {
+    return Object.entries(vars).map(([k, val])=>`${k}:${val}`).join(';');
+}
+/** Return an inline `style` string of theme variables, or '' when no theme is given. */ function themeStyle(theme) {
+    if (!theme) return '';
+    if (!('light' in theme)) return toCss(paletteVars(theme));
+    const light = paletteVars(theme.light);
+    const dark = paletteVars(theme.dark);
+    const merged = {};
+    for (const key of Object.keys(light))merged[key] = lightDark(light[key], dark[key]);
+    return toCss(merged);
+}
+/** Emit a copyable CSS block of --fp-* variables for a given selector. */ function themeCss(selector, theme) {
+    if (!('light' in theme)) {
+        const vars = paletteVars(theme);
+        const lines = Object.entries(vars).map(([k, v])=>`  ${k}: ${v};`);
+        return `${selector} {\n${lines.join('\n')}\n}`;
+    }
+    const lightVars = paletteVars(theme.light);
+    const darkVars = paletteVars(theme.dark);
+    const lightLines = Object.entries(lightVars).map(([k, v])=>`  ${k}: ${v};`);
+    const darkLines = Object.entries(darkVars).map(([k, v])=>`  ${k}: ${v};`);
+    return [
+        `${selector} {\n${lightLines.join('\n')}\n}`,
+        `@media (prefers-color-scheme: dark) {\n  ${selector} {\n  ${darkLines.join('\n  ')}\n  }\n}`,
+        `[data-theme="dark"] ${selector}, ${selector}[data-theme="dark"] {\n${darkLines.join('\n')}\n}`
+    ].join('\n\n');
+}
+/** SvelteKit theme (Light) */ const sveltekitLight = {
+    background: '#FFFFFF',
+    foreground: '#313131',
+    class: '#DE2D00',
+    identifier: '#414141',
+    sign: '#FF4500',
+    property: '#787676',
+    entity: '#313131',
+    jsxliterals: '#FA3701',
+    string: '#FA3701',
+    keyword: '#FA3701',
+    comment: '#6e6d6d',
+    caret: '#FF4500'
+};
+/** SvelteKit theme (Dark) */ const sveltekitDark = {
+    background: '#212121',
+    foreground: '#c7c6c6',
+    class: '#DE2D00',
+    identifier: '#7a7878',
+    sign: '#FF4500',
+    property: '#e1dfdf',
+    entity: '#fff8f8',
+    jsxliterals: '#FA3701',
+    string: '#FA3701',
+    keyword: '#FA3701',
+    comment: '#6e6d6d',
+    caret: '#FF4500'
+};
+/** SvelteKit theme (adaptive light/dark via CSS light-dark()) */ const sveltekit = {
+    light: sveltekitLight,
+    dark: sveltekitDark
+};
+/** VS Code theme (Light) */ const vscodeLight = {
+    background: '#f6f8fa',
+    foreground: '#24292f',
+    class: '#6f42c1',
+    identifier: '#24292f',
+    sign: '#24292f',
+    property: '#0550ae',
+    entity: '#953800',
+    jsxliterals: '#8250df',
+    string: '#032f62',
+    keyword: '#cf222e',
+    comment: '#6e7781',
+    caret: '#24292f'
+};
+/** VS Code theme (Dark) */ const vscodeDark = {
+    background: '#1e1e1e',
+    foreground: '#9cdcfe',
+    class: '#4ec9b0',
+    identifier: '#9cdcfe',
+    sign: '#d4d4d4',
+    property: '#9cdcfe',
+    entity: '#dcdcaa',
+    jsxliterals: '#ff8c42',
+    string: '#ce9178',
+    keyword: '#569cd6',
+    comment: '#6a9955',
+    caret: '#aeafad'
+};
+/** VS Code theme (adaptive light/dark via CSS light-dark()) */ const vscode = {
+    light: vscodeLight,
+    dark: vscodeDark
+};
+/** Shipped default themes bundle */ const themes = {
+    sveltekit,
+    sveltekitLight,
+    sveltekitDark,
+    vscode,
+    vscodeLight,
+    vscodeDark
+};
+
+export { paletteVars, sveltekit, sveltekitDark, sveltekitLight, themeCss, themeStyle, themes, tokenKeys, vscode, vscodeDark, vscodeLight };

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "@fractaldesign/pop",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Lightweight, Svelte-first syntax highlighting with first-class indented Sass. Returns HTML without a DOM.",
+  "type": "module",
+  "sideEffects": [
+    "./dist/full.js"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fractalmandala/fractalpop.git",
+    "directory": "packages/core"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "default": "./dist/core.js"
+    },
+    "./lang": {
+      "types": "./dist/lang.d.ts",
+      "default": "./dist/lang.js"
+    },
+    "./lang/*": {
+      "types": "./dist/lang/*.d.ts",
+      "default": "./dist/lang/*.js"
+    },
+    "./full": {
+      "types": "./dist/full.d.ts",
+      "default": "./dist/full.js"
+    },
+    "./gpu": {
+      "types": "./dist/gpu.d.ts",
+      "default": "./dist/gpu.js"
+    },
+    "./theme": {
+      "types": "./dist/theme.d.ts",
+      "default": "./dist/theme.js"
+    }
+  },
+  "peerDependencies": {
+    "gpu-lexer": ">=0.0.2"
+  },
+  "peerDependenciesMeta": {
+    "gpu-lexer": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bunchee",
+    "dev": "bunchee --watch",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "bunchee": "^6.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.11"
+  }
+}