fractalpop 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/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "fractalpop",
+  "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"
+    }
+  },
+  "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"
+  }
+}