gemcss 0.3.0 → 0.4.0

package/dist/plugin/core/parser.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GemcssParseError = void 0;
+exports.parseCss = parseCss;
+exports.buildModule = buildModule;
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_selector_parser_1 = __importDefault(require("postcss-selector-parser"));
+/** Thrown when a class name violates the naming convention. */
+class GemcssParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GemcssParseError';
+    }
+}
+exports.GemcssParseError = GemcssParseError;
+function ctx(from) {
+    return from ? ` (in ${from})` : '';
+}
+/**
+ * Extract class selectors from CSS source and build the model.
+ * Classes keep the order of their first appearance.
+ */
+function parseCss(css, opts = {}) {
+    const root = postcss_1.default.parse(css, { from: opts.from });
+    const classNames = [];
+    const seen = new Set();
+    root.walkRules((rule) => {
+        (0, postcss_selector_parser_1.default)((selectors) => {
+            selectors.walkClasses((cls) => {
+                if (!seen.has(cls.value)) {
+                    seen.add(cls.value);
+                    classNames.push(cls.value);
+                }
+            });
+        }).processSync(rule.selector);
+    });
+    return buildModule(classNames, opts.from);
+}
+/**
+ * Build the model from a list of raw class names.
+ * Convention: `block`, `block_bool`, `block_key_value`.
+ */
+function buildModule(classNames, from) {
+    const blocks = {};
+    for (const raw of classNames) {
+        const segments = raw.split('_');
+        const blockName = segments[0];
+        if (!blockName) {
+            throw new GemcssParseError(`Empty block name in class ".${raw}"${ctx(from)}`);
+        }
+        const block = (blocks[blockName] ??= {
+            name: blockName,
+            modifiers: {},
+        });
+        const tail = segments.slice(1);
+        if (tail.length === 0)
+            continue;
+        if (tail.length === 1) {
+            const key = tail[0];
+            if (!key)
+                throw new GemcssParseError(`Empty modifier in class ".${raw}"${ctx(from)}`);
+            assignBool(block, key, raw, from);
+            continue;
+        }
+        if (tail.length === 2) {
+            const key = tail[0];
+            const value = tail[1];
+            if (!key || !value) {
+                throw new GemcssParseError(`Empty modifier key/value in class ".${raw}"${ctx(from)}`);
+            }
+            assignEnum(block, key, value, raw, from);
+            continue;
+        }
+        throw new GemcssParseError(`Class ".${raw}" has more than one modifier segment after block "${blockName}". ` +
+            `Allowed: block, block_bool, block_key_value.${ctx(from)}`);
+    }
+    return { blocks };
+}
+function assignBool(block, key, raw, from) {
+    const existing = block.modifiers[key];
+    if (existing && existing.kind === 'enum') {
+        throw new GemcssParseError(`Modifier "${key}" of block "${block.name}" used as both boolean (".${raw}") and enum.${ctx(from)}`);
+    }
+    block.modifiers[key] = { kind: 'bool' };
+}
+function assignEnum(block, key, value, raw, from) {
+    const existing = block.modifiers[key];
+    if (existing && existing.kind === 'bool') {
+        throw new GemcssParseError(`Modifier "${key}" of block "${block.name}" used as both enum (".${raw}") and boolean.${ctx(from)}`);
+    }
+    const mod = existing && existing.kind === 'enum'
+        ? existing
+        : (block.modifiers[key] = { kind: 'enum', values: [] });
+    if (!mod.values.includes(value)) {
+        mod.values.push(value);
+    }
+}

package/dist/plugin/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/plugin/ts-plugin/generate-dts.d.ts

@@ -0,0 +1,2 @@
+/** Generate the `.d.ts` text for a `*.module.css`. Never throws. */
+export declare function dtsForFile(fileName: string, read?: (f: string) => string | undefined): string;

package/dist/plugin/ts-plugin/generate-dts.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dtsForFile = dtsForFile;
+const node_fs_1 = require("node:fs");
+const dts_js_1 = require("../core/dts.js");
+const parser_js_1 = require("../core/parser.js");
+/** Permissive fallback for CSS that is unreadable or violates the convention —
+ * keeps the editor usable on a broken file. */
+const FALLBACK = 'declare const gems: Record<string, (props?: Record<string, string | boolean>) => string>;\n' +
+    'export default gems;\n';
+/** Generate the `.d.ts` text for a `*.module.css`. Never throws. */
+function dtsForFile(fileName, read = defaultRead) {
+    const css = read(fileName);
+    if (css == null)
+        return FALLBACK;
+    try {
+        return (0, dts_js_1.generateDts)((0, parser_js_1.parseCss)(css, { from: fileName }));
+    }
+    catch {
+        return FALLBACK;
+    }
+}
+function defaultRead(f) {
+    try {
+        return (0, node_fs_1.readFileSync)(f, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/plugin/ts-plugin.cjs

@@ -0,0 +1,53 @@
+"use strict";
+const node_path_1 = require("node:path");
+const generate_dts_js_1 = require("./ts-plugin/generate-dts.js");
+const MODULE_CSS = /\.module\.css$/;
+/**
+ * TS language service plugin: types for `import gems from './x.module.css'`
+ * without declaration files on disk. Patches the languageServiceHost:
+ *  - getScriptKind     -> TS for `*.module.css`
+ *  - getScriptSnapshot -> the generated `.d.ts`
+ *  - resolveModuleNameLiterals -> resolves the import to that virtual Dts
+ */
+function init({ typescript: ts }) {
+    function create(info) {
+        const host = info.languageServiceHost;
+        const read = (f) => host.readFile?.(f);
+        const origKind = host.getScriptKind?.bind(host);
+        host.getScriptKind = (fileName) => {
+            if (MODULE_CSS.test(fileName))
+                return ts.ScriptKind.TS;
+            return origKind ? origKind(fileName) : ts.ScriptKind.Unknown;
+        };
+        const origSnapshot = host.getScriptSnapshot.bind(host);
+        host.getScriptSnapshot = (fileName) => {
+            if (MODULE_CSS.test(fileName)) {
+                return ts.ScriptSnapshot.fromString((0, generate_dts_js_1.dtsForFile)(fileName, read));
+            }
+            return origSnapshot(fileName);
+        };
+        if (host.resolveModuleNameLiterals) {
+            const origResolve = host.resolveModuleNameLiterals.bind(host);
+            host.resolveModuleNameLiterals = (literals, containingFile, ...rest) => {
+                const resolved = origResolve(literals, containingFile, ...rest);
+                return literals.map((literal, i) => {
+                    const name = literal.text;
+                    if (MODULE_CSS.test(name)) {
+                        const fileName = name.startsWith('.') ? (0, node_path_1.resolve)((0, node_path_1.dirname)(containingFile), name) : name;
+                        return {
+                            resolvedModule: {
+                                resolvedFileName: fileName,
+                                extension: ts.Extension.Dts,
+                                isExternalLibraryImport: false,
+                            },
+                        };
+                    }
+                    return resolved[i];
+                });
+            };
+        }
+        return info.languageService;
+    }
+    return { create };
+}
+module.exports = init;

package/dist/{ts-plugin.d.cts → plugin/ts-plugin.d.cts}

@@ -1,5 +1,4 @@
-import tsModule from 'typescript/lib/tsserverlibrary';
-
+import type tsModule from 'typescript/lib/tsserverlibrary';
 interface InitArgs {
     typescript: typeof tsModule;
 }
@@ -11,5 +10,4 @@ interface InitArgs {
  *  - resolveModuleNameLiterals -> resolves the import to that virtual Dts
  */
 declare function init({ typescript: ts }: InitArgs): tsModule.server.PluginModule;
-
 export = init;

package/dist/runtime.d.ts

@@ -1,12 +1,10 @@
 /** Props passed to a gem function: boolean flags and enum values. */
-type GemProps = Record<string, string | boolean | undefined>;
+export type GemProps = Record<string, string | boolean | undefined>;
 /** A block's class combinator function. */
-type Gem = (props?: GemProps) => string;
+export type Gem = (props?: GemProps) => string;
 /**
  * Build the `gems` object from a list of block names and a `raw → scoped` map.
  * Every block is a function: called with no arguments it returns the base class,
  * called with props it appends the classes of the active modifiers.
  */
-declare function createGems(blocks: string[], scoped: Record<string, string>): Record<string, Gem>;
-
-export { type Gem, type GemProps, createGems };
+export declare function createGems(blocks: string[], scoped: Record<string, string>): Record<string, Gem>;

package/dist/runtime.js

@@ -1,24 +1,27 @@
-// src/runtime.ts
-function createGems(blocks, scoped) {
-  const gems = {};
-  for (const name of blocks) {
-    const base = scoped[name] ?? name;
-    gems[name] = (props) => {
-      if (!props) return base;
-      let out = base;
-      for (const key in props) {
-        const v = props[key];
-        if (v === true) {
-          out += " " + (scoped[`${name}_${key}`] ?? `${name}_${key}`);
-        } else if (v != null && v !== false) {
-          out += " " + (scoped[`${name}_${key}_${v}`] ?? `${name}_${key}_${v}`);
-        }
-      }
-      return out;
-    };
-  }
-  return gems;
+/**
+ * Build the `gems` object from a list of block names and a `raw → scoped` map.
+ * Every block is a function: called with no arguments it returns the base class,
+ * called with props it appends the classes of the active modifiers.
+ */
+export function createGems(blocks, scoped) {
+    const gems = {};
+    for (const name of blocks) {
+        const base = scoped[name] ?? name;
+        gems[name] = (props) => {
+            if (!props)
+                return base;
+            let out = base;
+            for (const key in props) {
+                const v = props[key];
+                if (v === true) {
+                    out += ' ' + (scoped[`${name}_${key}`] ?? `${name}_${key}`); // bool
+                }
+                else if (v != null && v !== false) {
+                    out += ' ' + (scoped[`${name}_${key}_${v}`] ?? `${name}_${key}_${v}`); // enum
+                }
+            }
+            return out;
+        };
+    }
+    return gems;
 }
-export {
-  createGems
-};

package/dist/vite.d.ts

@@ -1,11 +1,10 @@
-import { Plugin } from 'vite';
-import { C as CompileOptions } from './compile-Br7cHtI1.js';
-
+import type { Plugin } from 'vite';
+import { type CompileOptions } from './core/compile.js';
 /**
  * Compile a CSS module into a gems JS module plus a virtual CSS id.
  * A pure function — testable without Vite.
  */
-declare function buildGemsModule(file: string, code: string, options?: CompileOptions, runtimeImport?: string): Promise<{
+export declare function buildGemsModule(file: string, code: string, options?: CompileOptions, runtimeImport?: string): Promise<{
     js: string;
     cssId: string;
     css: string;
@@ -15,6 +14,5 @@ declare function buildGemsModule(file: string, code: string, options?: CompileOp
  * The import resolves to a virtual JS module; the CSS goes back into the Vite
  * pipeline as a separate virtual `.css` import so it still gets injected.
  */
-declare function gemcss(options?: CompileOptions): Plugin;
-
-export { buildGemsModule, gemcss as default, gemcss };
+export declare function gemcss(options?: CompileOptions): Plugin;
+export default gemcss;

package/dist/vite.js

@@ -1,60 +1,62 @@
-import {
-  compile,
-  runtimePath
-} from "./chunk-DMYDRHTS.js";
-import "./chunk-CNXDOGPX.js";
-
-// src/vite.ts
-import { readFile } from "fs/promises";
-var MODULE_CSS_RE = /\.module\.css$/;
-var VIRTUAL_JS = "\0gemcss-js:";
-var VIRTUAL_CSS = "\0gemcss-css:";
+import { readFile } from 'node:fs/promises';
+import { compile } from './core/compile.js';
+import { runtimePath } from './core/runtime-path.js';
+const MODULE_CSS_RE = /\.module\.css$/;
+/** Virtual gems JS module. No `.css` in the id, or Vite would claim it as CSS. */
+const VIRTUAL_JS = '\0gemcss-js:';
+/** Virtual CSS for injection. The id is base64 — no `.module.`, or css-modules runs twice. */
+const VIRTUAL_CSS = '\0gemcss-css:';
 function isModuleCss(source) {
-  return MODULE_CSS_RE.test(source.split("?", 1)[0] ?? source);
+    return MODULE_CSS_RE.test(source.split('?', 1)[0] ?? source);
 }
-var enc = (s) => Buffer.from(s).toString("base64url");
-var dec = (s) => Buffer.from(s, "base64url").toString("utf8");
-async function buildGemsModule(file, code, options = {}, runtimeImport = "gemcss/runtime") {
-  const { css, scoped, module } = await compile(code, file, options);
-  const cssId = `${VIRTUAL_CSS}${enc(file)}.css`;
-  const js = `import ${JSON.stringify(cssId)};
-import { createGems } from ${JSON.stringify(runtimeImport)};
-export default createGems(${JSON.stringify(Object.keys(module.blocks))}, ${JSON.stringify(scoped)});
-`;
-  return { js, cssId, css };
+const enc = (s) => Buffer.from(s).toString('base64url');
+const dec = (s) => Buffer.from(s, 'base64url').toString('utf8');
+/**
+ * Compile a CSS module into a gems JS module plus a virtual CSS id.
+ * A pure function — testable without Vite.
+ */
+export async function buildGemsModule(file, code, options = {}, runtimeImport = 'gemcss/runtime') {
+    const { css, scoped, module } = await compile(code, file, options);
+    const cssId = `${VIRTUAL_CSS}${enc(file)}.css`;
+    const js = `import ${JSON.stringify(cssId)};\n` +
+        `import { createGems } from ${JSON.stringify(runtimeImport)};\n` +
+        `export default createGems(${JSON.stringify(Object.keys(module.blocks))}, ${JSON.stringify(scoped)});\n`;
+    return { js, cssId, css };
 }
-function gemcss(options = {}) {
-  const cssStore = /* @__PURE__ */ new Map();
-  return {
-    name: "gemcss",
-    enforce: "pre",
-    async resolveId(source, importer) {
-      if (source.startsWith(VIRTUAL_JS) || source.startsWith(VIRTUAL_CSS)) return source;
-      if (isModuleCss(source)) {
-        const resolved = await this.resolve(source, importer, { skipSelf: true });
-        if (resolved) return VIRTUAL_JS + enc(resolved.id);
-      }
-      return null;
-    },
-    async load(id) {
-      if (id.startsWith(VIRTUAL_CSS)) {
-        return cssStore.get(id) ?? "";
-      }
-      if (id.startsWith(VIRTUAL_JS)) {
-        const file = dec(id.slice(VIRTUAL_JS.length));
-        this.addWatchFile(file);
-        const code = await readFile(file, "utf8");
-        const { js, cssId, css } = await buildGemsModule(file, code, options, runtimePath());
-        cssStore.set(cssId, css);
-        return js;
-      }
-      return null;
-    }
-  };
+/**
+ * gemcss Vite plugin: `*.module.css` -> a typed `gems` object.
+ * The import resolves to a virtual JS module; the CSS goes back into the Vite
+ * pipeline as a separate virtual `.css` import so it still gets injected.
+ */
+export function gemcss(options = {}) {
+    const cssStore = new Map();
+    return {
+        name: 'gemcss',
+        enforce: 'pre',
+        async resolveId(source, importer) {
+            if (source.startsWith(VIRTUAL_JS) || source.startsWith(VIRTUAL_CSS))
+                return source;
+            if (isModuleCss(source)) {
+                const resolved = await this.resolve(source, importer, { skipSelf: true });
+                if (resolved)
+                    return VIRTUAL_JS + enc(resolved.id);
+            }
+            return null;
+        },
+        async load(id) {
+            if (id.startsWith(VIRTUAL_CSS)) {
+                return cssStore.get(id) ?? '';
+            }
+            if (id.startsWith(VIRTUAL_JS)) {
+                const file = dec(id.slice(VIRTUAL_JS.length));
+                this.addWatchFile(file);
+                const code = await readFile(file, 'utf8');
+                const { js, cssId, css } = await buildGemsModule(file, code, options, runtimePath());
+                cssStore.set(cssId, css);
+                return js;
+            }
+            return null;
+        },
+    };
 }
-var vite_default = gemcss;
-export {
-  buildGemsModule,
-  vite_default as default,
-  gemcss
-};
+export default gemcss;

package/dist/webpack.d.ts

@@ -1,13 +1,10 @@
-import { LoaderContext } from 'webpack';
-import { C as CompileOptions } from './compile-Br7cHtI1.js';
-
-type GemcssLoaderOptions = CompileOptions;
+import type { LoaderContext } from 'webpack';
+import { type CompileOptions } from './core/compile.js';
+export type GemcssLoaderOptions = CompileOptions;
 /**
  * Build the JS module for webpack: runtime CSS injection + a `gems` default export.
  * A pure function — testable without webpack.
  */
-declare function buildGemsModule(code: string, resourcePath: string, options?: CompileOptions, runtimeImport?: string): Promise<string>;
+export declare function buildGemsModule(code: string, resourcePath: string, options?: CompileOptions, runtimeImport?: string): Promise<string>;
 /** Webpack loader: `*.module.css` -> a `gems` JS module that injects its CSS at runtime. */
-declare function gemcssLoader(this: LoaderContext<GemcssLoaderOptions>, source: string): void;
-
-export { type GemcssLoaderOptions, buildGemsModule, gemcssLoader as default };
+export default function gemcssLoader(this: LoaderContext<GemcssLoaderOptions>, source: string): void;

package/dist/webpack.js

@@ -1,32 +1,24 @@
-import {
-  compile,
-  runtimePath
-} from "./chunk-DMYDRHTS.js";
-import "./chunk-CNXDOGPX.js";
-
-// src/webpack.ts
-async function buildGemsModule(code, resourcePath, options = {}, runtimeImport = runtimePath()) {
-  const { css, scoped, module } = await compile(code, resourcePath, options);
-  return `import { createGems } from ${JSON.stringify(runtimeImport)};
-const __css = ${JSON.stringify(css)};
-if (typeof document !== 'undefined') {
-  const __el = document.createElement('style');
-  __el.setAttribute('data-gemcss', ${JSON.stringify(resourcePath)});
-  __el.textContent = __css;
-  document.head.appendChild(__el);
+import { compile } from './core/compile.js';
+import { runtimePath } from './core/runtime-path.js';
+/**
+ * Build the JS module for webpack: runtime CSS injection + a `gems` default export.
+ * A pure function — testable without webpack.
+ */
+export async function buildGemsModule(code, resourcePath, options = {}, runtimeImport = runtimePath()) {
+    const { css, scoped, module } = await compile(code, resourcePath, options);
+    return (`import { createGems } from ${JSON.stringify(runtimeImport)};\n` +
+        `const __css = ${JSON.stringify(css)};\n` +
+        `if (typeof document !== 'undefined') {\n` +
+        `  const __el = document.createElement('style');\n` +
+        `  __el.setAttribute('data-gemcss', ${JSON.stringify(resourcePath)});\n` +
+        `  __el.textContent = __css;\n` +
+        `  document.head.appendChild(__el);\n` +
+        `}\n` +
+        `export default createGems(${JSON.stringify(Object.keys(module.blocks))}, ${JSON.stringify(scoped)});\n`);
 }
-export default createGems(${JSON.stringify(Object.keys(module.blocks))}, ${JSON.stringify(scoped)});
-`;
+/** Webpack loader: `*.module.css` -> a `gems` JS module that injects its CSS at runtime. */
+export default function gemcssLoader(source) {
+    const callback = this.async();
+    const options = (this.getOptions?.() ?? {});
+    buildGemsModule(source, this.resourcePath, options).then((js) => callback(null, js), (err) => callback(err instanceof Error ? err : new Error(String(err))));
 }
-function gemcssLoader(source) {
-  const callback = this.async();
-  const options = this.getOptions?.() ?? {};
-  buildGemsModule(source, this.resourcePath, options).then(
-    (js) => callback(null, js),
-    (err) => callback(err instanceof Error ? err : new Error(String(err)))
-  );
-}
-export {
-  buildGemsModule,
-  gemcssLoader as default
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemcss",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "type": "module",
   "description": "Typed BEM classes from CSS modules — every block becomes a modifier-combinator function, with types inferred from the CSS",
   "keywords": [
@@ -41,8 +41,8 @@
       "default": "./dist/webpack.js"
     },
     "./ts-plugin": {
-      "types": "./dist/ts-plugin.d.cts",
-      "default": "./dist/ts-plugin.cjs"
+      "types": "./dist/plugin/ts-plugin.d.cts",
+      "default": "./dist/plugin/ts-plugin.cjs"
     }
   },
   "files": [
@@ -56,7 +56,7 @@
     "postcss-selector-parser": "^7.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5",
+    "typescript": "^5 || ^6",
     "vite": "^5 || ^6 || ^7",
     "webpack": "^5"
   },
@@ -79,20 +79,19 @@
     "gemcss": "link:.",
     "prettier": "^3.4.2",
     "publint": "0.3.21",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.1",
+    "typescript": "^6",
+    "typescript-eslint": "^8.63.0",
     "vite": "^6.0.0",
     "vitest": "^2.1.8",
     "webpack": "^5.97.1"
   },
   "scripts": {
     "build": "pnpm build:lib && pnpm -r --filter 'example-*' build",
-    "build:lib": "pnpm clean && tsup && node scripts/fix-ts-plugin-dts.mjs",
+    "build:lib": "pnpm clean && tsc -p tsconfig.build.json && tsc -p tsconfig.plugin.json && node scripts/write-plugin-pkgjson.mjs",
     "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.plugin.json",
     "lint": "eslint .",
     "format": "prettier --write .",
     "format:check": "prettier --check .",

package/dist/chunk-CNXDOGPX.js

@@ -1,89 +0,0 @@
-// src/core/parser.ts
-import postcss from "postcss";
-import selectorParser from "postcss-selector-parser";
-var GemcssParseError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GemcssParseError";
-  }
-};
-function ctx(from) {
-  return from ? ` (in ${from})` : "";
-}
-function parseCss(css, opts = {}) {
-  const root = postcss.parse(css, { from: opts.from });
-  const classNames = [];
-  const seen = /* @__PURE__ */ new Set();
-  root.walkRules((rule) => {
-    selectorParser((selectors) => {
-      selectors.walkClasses((cls) => {
-        if (!seen.has(cls.value)) {
-          seen.add(cls.value);
-          classNames.push(cls.value);
-        }
-      });
-    }).processSync(rule.selector);
-  });
-  return buildModule(classNames, opts.from);
-}
-function buildModule(classNames, from) {
-  const blocks = {};
-  for (const raw of classNames) {
-    const segments = raw.split("_");
-    const blockName = segments[0];
-    if (!blockName) {
-      throw new GemcssParseError(`Empty block name in class ".${raw}"${ctx(from)}`);
-    }
-    const block = blocks[blockName] ??= {
-      name: blockName,
-      modifiers: {}
-    };
-    const tail = segments.slice(1);
-    if (tail.length === 0) continue;
-    if (tail.length === 1) {
-      const key = tail[0];
-      if (!key) throw new GemcssParseError(`Empty modifier in class ".${raw}"${ctx(from)}`);
-      assignBool(block, key, raw, from);
-      continue;
-    }
-    if (tail.length === 2) {
-      const key = tail[0];
-      const value = tail[1];
-      if (!key || !value) {
-        throw new GemcssParseError(`Empty modifier key/value in class ".${raw}"${ctx(from)}`);
-      }
-      assignEnum(block, key, value, raw, from);
-      continue;
-    }
-    throw new GemcssParseError(
-      `Class ".${raw}" has more than one modifier segment after block "${blockName}". Allowed: block, block_bool, block_key_value.${ctx(from)}`
-    );
-  }
-  return { blocks };
-}
-function assignBool(block, key, raw, from) {
-  const existing = block.modifiers[key];
-  if (existing && existing.kind === "enum") {
-    throw new GemcssParseError(
-      `Modifier "${key}" of block "${block.name}" used as both boolean (".${raw}") and enum.${ctx(from)}`
-    );
-  }
-  block.modifiers[key] = { kind: "bool" };
-}
-function assignEnum(block, key, value, raw, from) {
-  const existing = block.modifiers[key];
-  if (existing && existing.kind === "bool") {
-    throw new GemcssParseError(
-      `Modifier "${key}" of block "${block.name}" used as both enum (".${raw}") and boolean.${ctx(from)}`
-    );
-  }
-  const mod = existing && existing.kind === "enum" ? existing : block.modifiers[key] = { kind: "enum", values: [] };
-  if (!mod.values.includes(value)) {
-    mod.values.push(value);
-  }
-}
-
-export {
-  GemcssParseError,
-  parseCss
-};