@jesscss/scss-parser 2.0.0-alpha.7 → 2.0.0-alpha.9

package/lib/index.cjs

@@ -1,14 +1,111 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_functional_parser = require("./functional-parser.cjs");
-const require_grammar = require("./grammar.cjs");
-const require_cst = require("./cst.cjs");
+const require_ast_grammar = require("./ast/grammar.cjs");
+let parseman = require("parseman");
+let _jesscss_core_ast = require("@jesscss/core/ast");
+//#region src/ast/lower-user-function-calls.ts
+/**
+* SCSS call-site lowering: a user `@function f(...)` was lowered (in the grammar)
+* to a `$var`-bound value lambda (`AnonymousMixin` with `params`). A CALL to that
+* function — `f(2)` — parses as an ordinary `FunctionCall`, indistinguishable at
+* the leaf from a builtin Sass call (`darken(...)`). This post-parse pass rewrites
+* every `FunctionCall` whose name is a USER-defined `@function` into the shared
+* `$f(args)` invoke form (a `Reference` with a `Call` step on the bound variable),
+* so it reaches the general "call a value-lambda" evaluator path. Builtin Sass
+* functions are left as `FunctionCall`s and continue to route to `fns`.
+*
+* User-function names are collected from the WHOLE document first (Sass hoists and
+* effectively globalises function definitions), so a call may precede its `@function`.
+* The only SCSS construct that binds an `AnonymousMixin` to a `$var` is `@function`,
+* so "a VariableDeclaration whose value is an AnonymousMixin" is an exact marker.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFunctionCall(value) {
+	return isRecord(value) && value.type === "FunctionCall" && typeof value.name === "string" && Array.isArray(value.args);
+}
+/** A non-array value slot is a single value node. */
+function isValueNode(slot) {
+	return !Array.isArray(slot);
+}
+function isStylesheet$1(value) {
+	return isRecord(value) && value.type === "Stylesheet" && Array.isArray(value.children);
+}
+/** Collect every user `@function` name: a VariableDeclaration bound to an
+*  AnonymousMixin (the only SCSS shape that produces one). */
+function collectUserFunctionNames(node, into) {
+	if (Array.isArray(node)) {
+		for (const child of node) collectUserFunctionNames(child, into);
+		return;
+	}
+	if (!isRecord(node)) return;
+	if (node.type === "VariableDeclaration" && typeof node.name === "string" && isRecord(node.value) && node.value.type === "AnonymousMixin") into.add(node.name);
+	for (const key of Object.keys(node)) collectUserFunctionNames(node[key], into);
+}
+/** Best-effort authored spelling of a call argument, for a Reference `raw`
+*  fallback (only ever emitted if the invoke fails to resolve). */
+function argRaw(slot) {
+	if (!isValueNode(slot)) return slot.map(argRaw).join(" ");
+	if (slot.type === "VariableReference") return `$${slot.name}`;
+	if ("src" in slot && typeof slot.src === "string") return slot.src;
+	return "";
+}
+/** Deep-transform the tree, rewriting user-function `FunctionCall`s (post-order,
+*  so nested user calls inside the args lower first). Non-AST scalars pass through. */
+function rewrite(node, userFns) {
+	if (Array.isArray(node)) return node.map((child) => rewrite(child, userFns));
+	if (!isRecord(node)) return node;
+	const out = {};
+	for (const key of Object.keys(node)) out[key] = rewrite(node[key], userFns);
+	if (isFunctionCall(out) && userFns.has(out.name)) {
+		const args = out.args.map((value) => ({ value }));
+		const raw = `${out.name}(${out.args.map(argRaw).join(", ")})`;
+		return (0, _jesscss_core_ast.reference)((0, _jesscss_core_ast.variableReference)(out.name, "live"), [{
+			type: "Call",
+			args
+		}], raw);
+	}
+	return out;
+}
+/**
+* Rewrite user-`@function` call sites in a parsed SCSS document to `$f(args)`
+* lambda invokes. Returns the document unchanged when it defines no user function.
+*/
+function lowerUserFunctionCalls(sheet) {
+	const userFns = /* @__PURE__ */ new Set();
+	collectUserFunctionNames(sheet.children, userFns);
+	if (userFns.size === 0) return sheet;
+	const lowered = rewrite(sheet, userFns);
+	if (!isStylesheet$1(lowered)) throw new TypeError("SCSS user-function lowering did not preserve the Stylesheet root.");
+	return lowered;
+}
+//#endregion
 //#region src/index.ts
-const Parser = require_functional_parser.ScssParser;
+/** Structured failure from the public direct SCSS parser. */
+var ScssParseError = class extends SyntaxError {
+	code = "parse/syntax-error";
+	offset;
+	expected;
+	constructor(offset, expected) {
+		const detail = expected.length > 0 ? ` Expected: ${expected.join(", ")}.` : "";
+		super(`SCSS parser error.${detail}`);
+		this.name = "ScssParseError";
+		this.offset = offset;
+		this.expected = expected;
+	}
+};
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "children" in value && Array.isArray(value.children);
+}
+/** Parse SCSS directly into the canonical AST v2 document. */
+function parse(input) {
+	const entry = require_ast_grammar.scssAstGrammar.ScssAstDocument;
+	const trivia = require_ast_grammar.scssAstGrammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("SCSS AST grammar is missing its public document entry.");
+	const result = (0, parseman.run)(entry, input, { trivia });
+	if (!result.ok || result.unconsumedFrom !== null || !isStylesheet(result.value)) throw new ScssParseError(result.ok ? result.unconsumedFrom ?? result.span.end : result.span.start, result.expected);
+	return lowerUserFunctionCalls(result.value);
+}
 //#endregion
-exports.Parser = Parser;
-exports.ScssGrammar = require_functional_parser.ScssGrammar;
-exports.ScssParser = require_functional_parser.ScssParser;
-exports.parseScssCst = require_cst.parseScssCst;
-exports.parseScssDoc = require_cst.parseScssDoc;
-exports.parseScssFn = require_functional_parser.parseScssFn;
-exports.scssGrammar = require_grammar.scssGrammar;
+exports.ScssParseError = ScssParseError;
+exports.parse = parse;

package/lib/index.d.ts

@@ -1,7 +1,10 @@
-export { ScssGrammar } from './builders.js';
-export { scssGrammar } from './grammar.js';
-import { ScssParser } from './functional-parser.js';
-export { ScssParser, parseScssFn, type ScssFnParseResult, type ScssFnParseOptions } from './functional-parser.js';
-export declare const Parser: typeof ScssParser;
-export { parseScssCst, parseScssDoc } from './cst.js';
-export type { ScssCstChild, ScssCstError, ScssCstLeaf, ScssCstNode, ScssCstParseResult, ScssCstType } from './cst.js';
+import type { Stylesheet } from '@jesscss/core/ast';
+/** Structured failure from the public direct SCSS parser. */
+export declare class ScssParseError extends SyntaxError {
+    readonly code: 'parse/syntax-error';
+    readonly offset: number;
+    readonly expected: readonly string[];
+    constructor(offset: number, expected: readonly string[]);
+}
+/** Parse SCSS directly into the canonical AST v2 document. */
+export declare function parse(input: string): Stylesheet;

package/lib/index.js

@@ -1,7 +1,109 @@
-import { n as parseScssFn, r as ScssGrammar, t as ScssParser } from "./functional-parser.js";
-import { scssGrammar } from "./grammar.js";
-import { parseScssCst, parseScssDoc } from "./cst.js";
+import { scssAstGrammar } from "./ast/grammar.js";
+import { run } from "parseman";
+import { reference, variableReference } from "@jesscss/core/ast";
+//#region src/ast/lower-user-function-calls.ts
+/**
+* SCSS call-site lowering: a user `@function f(...)` was lowered (in the grammar)
+* to a `$var`-bound value lambda (`AnonymousMixin` with `params`). A CALL to that
+* function — `f(2)` — parses as an ordinary `FunctionCall`, indistinguishable at
+* the leaf from a builtin Sass call (`darken(...)`). This post-parse pass rewrites
+* every `FunctionCall` whose name is a USER-defined `@function` into the shared
+* `$f(args)` invoke form (a `Reference` with a `Call` step on the bound variable),
+* so it reaches the general "call a value-lambda" evaluator path. Builtin Sass
+* functions are left as `FunctionCall`s and continue to route to `fns`.
+*
+* User-function names are collected from the WHOLE document first (Sass hoists and
+* effectively globalises function definitions), so a call may precede its `@function`.
+* The only SCSS construct that binds an `AnonymousMixin` to a `$var` is `@function`,
+* so "a VariableDeclaration whose value is an AnonymousMixin" is an exact marker.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFunctionCall(value) {
+	return isRecord(value) && value.type === "FunctionCall" && typeof value.name === "string" && Array.isArray(value.args);
+}
+/** A non-array value slot is a single value node. */
+function isValueNode(slot) {
+	return !Array.isArray(slot);
+}
+function isStylesheet$1(value) {
+	return isRecord(value) && value.type === "Stylesheet" && Array.isArray(value.children);
+}
+/** Collect every user `@function` name: a VariableDeclaration bound to an
+*  AnonymousMixin (the only SCSS shape that produces one). */
+function collectUserFunctionNames(node, into) {
+	if (Array.isArray(node)) {
+		for (const child of node) collectUserFunctionNames(child, into);
+		return;
+	}
+	if (!isRecord(node)) return;
+	if (node.type === "VariableDeclaration" && typeof node.name === "string" && isRecord(node.value) && node.value.type === "AnonymousMixin") into.add(node.name);
+	for (const key of Object.keys(node)) collectUserFunctionNames(node[key], into);
+}
+/** Best-effort authored spelling of a call argument, for a Reference `raw`
+*  fallback (only ever emitted if the invoke fails to resolve). */
+function argRaw(slot) {
+	if (!isValueNode(slot)) return slot.map(argRaw).join(" ");
+	if (slot.type === "VariableReference") return `$${slot.name}`;
+	if ("src" in slot && typeof slot.src === "string") return slot.src;
+	return "";
+}
+/** Deep-transform the tree, rewriting user-function `FunctionCall`s (post-order,
+*  so nested user calls inside the args lower first). Non-AST scalars pass through. */
+function rewrite(node, userFns) {
+	if (Array.isArray(node)) return node.map((child) => rewrite(child, userFns));
+	if (!isRecord(node)) return node;
+	const out = {};
+	for (const key of Object.keys(node)) out[key] = rewrite(node[key], userFns);
+	if (isFunctionCall(out) && userFns.has(out.name)) {
+		const args = out.args.map((value) => ({ value }));
+		const raw = `${out.name}(${out.args.map(argRaw).join(", ")})`;
+		return reference(variableReference(out.name, "live"), [{
+			type: "Call",
+			args
+		}], raw);
+	}
+	return out;
+}
+/**
+* Rewrite user-`@function` call sites in a parsed SCSS document to `$f(args)`
+* lambda invokes. Returns the document unchanged when it defines no user function.
+*/
+function lowerUserFunctionCalls(sheet) {
+	const userFns = /* @__PURE__ */ new Set();
+	collectUserFunctionNames(sheet.children, userFns);
+	if (userFns.size === 0) return sheet;
+	const lowered = rewrite(sheet, userFns);
+	if (!isStylesheet$1(lowered)) throw new TypeError("SCSS user-function lowering did not preserve the Stylesheet root.");
+	return lowered;
+}
+//#endregion
 //#region src/index.ts
-const Parser = ScssParser;
+/** Structured failure from the public direct SCSS parser. */
+var ScssParseError = class extends SyntaxError {
+	code = "parse/syntax-error";
+	offset;
+	expected;
+	constructor(offset, expected) {
+		const detail = expected.length > 0 ? ` Expected: ${expected.join(", ")}.` : "";
+		super(`SCSS parser error.${detail}`);
+		this.name = "ScssParseError";
+		this.offset = offset;
+		this.expected = expected;
+	}
+};
+function isStylesheet(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "Stylesheet" && "children" in value && Array.isArray(value.children);
+}
+/** Parse SCSS directly into the canonical AST v2 document. */
+function parse(input) {
+	const entry = scssAstGrammar.ScssAstDocument;
+	const trivia = scssAstGrammar.whitespace;
+	if (entry === void 0 || trivia === void 0) throw new TypeError("SCSS AST grammar is missing its public document entry.");
+	const result = run(entry, input, { trivia });
+	if (!result.ok || result.unconsumedFrom !== null || !isStylesheet(result.value)) throw new ScssParseError(result.ok ? result.unconsumedFrom ?? result.span.end : result.span.start, result.expected);
+	return lowerUserFunctionCalls(result.value);
+}
 //#endregion
-export { Parser, ScssGrammar, ScssParser, parseScssCst, parseScssDoc, parseScssFn, scssGrammar };
+export { ScssParseError, parse };

package/package.json

@@ -4,47 +4,37 @@
     "access": "public"
   },
   "description": "",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.9",
   "main": "lib/index.cjs",
   "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",
-      "source": "./src/index.ts",
       "import": "./lib/index.js",
       "require": "./lib/index.cjs"
     },
     "./cst": {
       "types": "./lib/cst.d.ts",
-      "source": "./src/cst.ts",
       "import": "./lib/cst.js",
       "require": "./lib/cst.cjs"
     },
     "./grammar": {
       "types": "./lib/grammar.d.ts",
-      "source": "./src/grammar.ts",
       "import": "./lib/grammar.js",
       "require": "./lib/grammar.cjs"
     },
-    "./jess": {
-      "types": "./lib/jess.d.ts",
-      "source": "./src/jess.ts",
-      "import": "./lib/jess.js",
-      "require": "./lib/jess.cjs"
-    },
     "./package.json": "./package.json"
   },
   "files": [
-    "lib",
-    "src"
+    "lib"
   ],
   "dependencies": {
-    "chevrotain": "^12.0.0",
-    "@jesscss/css-parser": "2.0.0-alpha.7",
-    "@jesscss/less-parser": "2.0.0-alpha.7"
+    "@jesscss/css-parser": "2.0.0-alpha.9",
+    "@jesscss/less-parser": "2.0.0-alpha.9"
   },
   "peerDependencies": {
-    "@jesscss/core": "2.0.0-alpha.7"
+    "parseman": "^0.30.0",
+    "@jesscss/core": "2.0.0-alpha.9"
   },
   "peerDependenciesMeta": {
     "@jesscss/core": {
@@ -52,9 +42,10 @@
     }
   },
   "devDependencies": {
-    "parseman": "0.25.0",
+    "parseman": "0.30.0",
     "sass-spec": "github:sass/sass-spec",
-    "@jesscss/core": "2.0.0-alpha.7"
+    "@jesscss/core": "2.0.0-alpha.9",
+    "@jesscss/internal-css-recognition": "0.0.0"
   },
   "author": "Matthew Dean <matthew-dean@users.noreply.github.com>",
   "license": "MIT",
@@ -67,12 +58,11 @@
   "scripts": {
     "postinstall": "node ./scripts/materialize-sass-spec-cache.cjs",
     "ci": "pnpm build && pnpm test",
-    "build": "pnpm compile",
+    "build": "pnpm --filter @jesscss/internal-css-recognition build && pnpm compile",
     "compile": "tsdown --tsconfig tsconfig.build.json --no-dts && ../../node_modules/.bin/tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck",
     "dev": "tsdown --tsconfig tsconfig.build.json --no-dts --watch",
     "sass-spec:cache": "node ./scripts/materialize-sass-spec-cache.cjs",
     "test": "vitest --run --passWithNoTests",
-    "test:parse": "vitest --run --passWithNoTests test/parse-only.test.ts test/sass-spec.smoke.test.ts",
     "lint:fix": "eslint --fix '**/*.{js,ts}'",
     "lint": "eslint '**/*.{js,ts}'"
   }

package/lib/builders.d.ts

@@ -1,154 +0,0 @@
-/**
- * ScssGrammar — Parséman-based SCSS parser, extending LessGrammar.
- *
- * Adds SCSS-specific grammar on top of Less (which in turn extends CSS):
- *   - Variable declarations: $var: value [!default|!global];  →  VarDeclaration
- *   - Variable references:   $var                             →  Reference
- *   - Line comments:         // ...  (added to rw trivia)
- *
- * Inherits from LessGrammar:
- *   - Nested rulesets, & ampersand, relative selectors
- *   - anyDeclaration entry point
- *   - atRuleBody, declarationList, Stylesheet overrides
- *   - Less merge operators on Declaration (harmless for SCSS)
- *
- * Chevrotain note: in the Chevrotain architecture, ScssRecursiveParser
- * extends CssRecursiveParser independently of LessRecursiveParser.
- * Here we take the Parséman inheritance chain
- * CssParser → LessGrammar → ScssGrammar to maximise code reuse.
- */
-import type { FieldMap, Span } from 'parseman';
-import type { CSTLeaf, CSTError } from 'parseman';
-import { LessGrammar } from '@jesscss/less-parser/jess';
-import { type Node, type LocationInfo, type TreeContext, Rules, Quoted } from '@jesscss/core';
-type JessNode = Node<any, any>;
-type Child = JessNode | CSTLeaf | CSTError;
-export declare class ScssGrammar extends LessGrammar {
-    rw: import("parseman").Combinator<string>;
-    protected _trivia: import("parseman").Combinator<string>;
-    protected _parseContext?: TreeContext;
-    setContext(context?: TreeContext): void;
-    scssVar: import("parseman").Combinator<string>;
-    VarDeclaration: (g: any) => import("parseman").Combinator<[unknown, string, unknown, string | null, string | null]>;
-    Reference: (g: any) => any;
-    protected buildNode(type: string, span: Span, children: ReadonlyArray<JessNode | CSTLeaf | CSTError>, _state: unknown, _rawChildren: ReadonlyArray<{
-        _tag: string;
-    }>, fields?: FieldMap, triviaLog?: readonly number[]): JessNode;
-    private _buildScssVarDeclaration;
-    /**
-     * `ns.$member: value [!default|!global];` — a namespaced variable ASSIGNMENT.
-     * Built as a `VarDeclaration` whose name carries the namespace (`ns.member`);
-     * `!default` → conditional-assign, `!global` → `setDefined`. Mirrors the
-     * member-read shape (`Reference{ target, key }`) on the write side while
-     * staying within the `string | Interpolated` declaration-name contract.
-     */
-    private _buildScssNsVarDeclaration;
-    private _buildScssReference;
-    /**
-     * `left [op right]` → Condition, or a bare operand when there is no operator.
-     * `!=` desugars to `=` + negate (matches the Chevrotain scssComparison).
-     */
-    private _buildScssComparison;
-    /**
-     * Every condition term is wrapped in a Paren, matching the Chevrotain
-     * `scssConditionInParens` production (both the `( … )` group and the bare
-     * comparison / value branch wrap their result in a single Paren).
-     */
-    private _buildScssCondInParens;
-    /** Optional leading `not` negates the term. */
-    private _buildScssCondTerm;
-    /** Fold a left-associative `and` / `or` chain of terms into Conditions. */
-    private _buildScssCondJoin;
-    /** A `{ … }` control-block body → Rules. */
-    private _buildScssRules;
-    /**
-     * `@if cond { … } (@else if cond { … })* (@else { … })?` → nested `If` chain.
-     * Children arrive as alternating condition / Rules nodes, with an optional
-     * trailing bare Rules (the final `@else`). Fold from the last branch inward.
-     */
-    private _buildScssIf;
-    /** A `$name` loop-binding with no value (`paramVar` — prints as `$name`). */
-    private _scssParamVar;
-    /**
-     * `@each $a[, $b …] in <expr> { … }` → `For` with a node iterable.
-     * Normalizes to Jess `$for ($a of …)` / `$for ([$a, $b] of …)`.
-     */
-    private _buildScssEach;
-    /**
-     * `@for $i from <start> (to|through) <end> { … }` → `For` with a range iterable.
-     * `through` is inclusive end; `to` is exclusive (`includeEnd: false`).
-     */
-    private _buildScssFor;
-    /** `@while <cond> { … }` → `While`. */
-    private _buildScssWhile;
-    /** Build a module-qualified or plain mixin `Reference`. */
-    private _buildScssMixinName;
-    /** `$x: val` keyword arg, `val...` spread, or plain value. */
-    private _buildScssCallArg;
-    private _buildScssCallArgsInner;
-    /** Mixin param: `...$rest`, `$rest...`, `$a: default`, or bare `$a`. */
-    private _buildScssMixinParam;
-    private _buildScssMixinParams;
-    /** `@mixin name($params) { … }` → `Mixin` (inner vars default to private). */
-    private _buildScssMixin;
-    /** `using ($c, $n)` param list for `@include … using (…)`. */
-    private _buildScssIncludeUsing;
-    /**
-     * `@include name(args) [using (…)] [ { … } ];` → `Call(Reference(type=mixin))`.
-     * An optional content block becomes an anonymous visible `Mixin` on the call.
-     */
-    private _buildScssInclude;
-    /** `@content[(args)];` → `Call(Reference('content', type=mixin))`. */
-    private _buildScssContent;
-    /** `@function name($params) { … }` → `Func` with `returnName: 'result'`. */
-    private _buildScssFunction;
-    /** `@return <value>;` → `$result: <value>;` */
-    private _buildScssReturn;
-    private _buildScssInterpBare;
-    /** `foo-#{$bar}` name segments → Interpolated(role=name) or plain Any. */
-    private _buildScssInterpolatedName;
-    private _buildScssInterpValue;
-    private _buildScssInterpolatedSelector;
-    private _scssInterpDeclName;
-    private _buildScssDeclaration;
-    private _buildScssCustomDeclaration;
-    protected _buildQuoted(children: ReadonlyArray<Child>, loc: LocationInfo): Node<any, any> | Quoted;
-    /** `("k": v, …)` pair inside a map literal. */
-    private _buildScssMapPair;
-    private _buildScssMapLiteral;
-    /** `ns.$var`, `ns.fn(…)`, `ns.\#foo(…)`, or a plain ident. */
-    private _buildScssIdentValue;
-    protected _buildStylesheet(children: ReadonlyArray<Child>, loc: LocationInfo): Rules<never, import("@jesscss/core").RulesOptions & Record<string, any> & {
-        semi?: boolean;
-    }>;
-    private _flattenScssImportLists;
-    private _buildScssNestedProps;
-    private _buildScssDiagnostic;
-    private _buildScssAtRootFilter;
-    private _buildScssAtRootSelector;
-    private _buildScssAtRootPlain;
-    private _buildScssWithConfigEntry;
-    private _buildScssWithConfig;
-    private _buildScssUseAs;
-    private _buildScssUse;
-    private _buildScssForward;
-    private _buildScssPlaceholderSelector;
-    private _buildScssPermissiveAtRule;
-    private _buildScssLayerBlock;
-    protected _buildQueryAtRuleBlock(children: ReadonlyArray<Child>, loc: LocationInfo): JessNode;
-    protected _buildScssParen(rawChildren: ReadonlyArray<{
-        _tag: string;
-    }>, loc: LocationInfo): JessNode;
-    private _buildScssExtendTarget;
-    private _scssExtendTargetFrom;
-    private _buildScssExtend;
-    private _buildScssImportItem;
-    private _buildScssImportAtRule;
-    protected _buildCall(rawChildren: ReadonlyArray<{
-        _tag: string;
-    }>, loc: LocationInfo): JessNode;
-    protected _buildSquareParen(rawChildren: ReadonlyArray<{
-        _tag: string;
-    }>, loc: LocationInfo): JessNode;
-}
-export {};