@codefast/cli 0.3.13-canary.2 → 0.3.13-canary.4

package/dist/lib/arrange/domain/grouping.js

@@ -1,307 +0,0 @@
-import { BUCKET_ORDER, MAX_GROUPS_BASE, MAX_GROUPS_CAP, MAX_GROUPS_HEADROOM, MIN_GROUP_TOKENS, } from "#lib/arrange/domain/constants";
-import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, selectorKey, stateKey, stripVariants, tokenizeClassString, } from "#lib/arrange/domain/tokenizer";
-function isVariantKeyedBucket(bucket) {
-    return bucket === "selector" || bucket === "state" || bucket === "starting";
-}
-function variantGroupKey(bucket, classToken) {
-    return bucket === "selector" ? selectorKey(classToken) : stateKey(classToken);
-}
-/**
- * True when `staticLiteralTexts` carries the **same partition** of Tailwind tokens as
- * `suggestedGroups` from {@link suggestCnGroups}, ignoring order of arguments and
- * order of tokens within each chunk.
- */
-export function areCnTailwindPartitionsEquivalent(staticLiteralTexts, suggestedGroups) {
-    const partitionSignatures = (chunks) => chunks
-        .map((chunk) => {
-        const classTokens = tokenizeClassString(chunk);
-        return classTokens.length === 0 ? "" : [...classTokens].sort().join(" ");
-    })
-        .filter((s) => s.length > 0)
-        .sort((a, b) => a.localeCompare(b));
-    const staticPartitionSigs = partitionSignatures(staticLiteralTexts);
-    const suggestedPartitionSigs = partitionSignatures(suggestedGroups);
-    if (staticPartitionSigs.length !== suggestedPartitionSigs.length) {
-        return false;
-    }
-    for (let i = 0; i < staticPartitionSigs.length; i++) {
-        if (staticPartitionSigs[i] !== suggestedPartitionSigs[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-/** Dominant bucket of a whitespace-delimited class group (for merge heuristics). */
-function dominantBucketOfGroup(groupStr) {
-    const counts = new Map();
-    for (const classToken of tokenizeClassString(groupStr)) {
-        const tokenBucket = classifyToken(classToken);
-        counts.set(tokenBucket, (counts.get(tokenBucket) ?? 0) + 1);
-    }
-    let best = "other";
-    let bestN = 0;
-    for (const [bucket, count] of counts) {
-        if (count > bestN) {
-            best = bucket;
-            bestN = count;
-            continue;
-        }
-        // Deterministic tie-break: prefer earlier render-pipeline bucket.
-        if (count === bestN && BUCKET_ORDER[bucket] < BUCKET_ORDER[best]) {
-            best = bucket;
-        }
-    }
-    return best;
-}
-/** Dynamic cap: more tokens → allow more groups, within [BASE, CAP]. */
-function dynamicMaxGroups(tokenCount) {
-    const byTokens = Math.ceil(tokenCount / 2) + MAX_GROUPS_HEADROOM;
-    return Math.max(MAX_GROUPS_BASE, Math.min(MAX_GROUPS_CAP, byTokens));
-}
-/**
- * Merge singleton groups (< MIN_GROUP_TOKENS tokens) into their nearest
- * neighbour. Prefers merging toward a bucket-compatible neighbor.
- *
- * Loop termination: each iteration either splices one element (shrinking the
- * array, guaranteeing progress) or finds no singleton that can merge and exits
- * via `changed = false`. Two mutually-incompatible singletons both hit
- * `continue` and `changed` stays false, so the loop exits without spinning.
- */
-export function mergeSingletons(groups) {
-    if (groups.length <= 1) {
-        return groups;
-    }
-    const result = [...groups];
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (let i = 0; i < result.length; i++) {
-            if (tokenizeClassString(result[i]).length < MIN_GROUP_TOKENS) {
-                if (result.length === 1) {
-                    break;
-                }
-                const myBucket = dominantBucketOfGroup(result[i]);
-                const prevCompat = i > 0 && bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i - 1]));
-                const nextCompat = i < result.length - 1 &&
-                    bucketsMergeCompatible(myBucket, dominantBucketOfGroup(result[i + 1]));
-                let mergeDir;
-                if (nextCompat && !prevCompat) {
-                    mergeDir = "forward";
-                }
-                else if (prevCompat && !nextCompat) {
-                    mergeDir = "backward";
-                }
-                else if (prevCompat && nextCompat) {
-                    mergeDir = i < result.length - 1 ? "forward" : "backward";
-                }
-                else {
-                    continue;
-                }
-                if (mergeDir === "forward") {
-                    result[i + 1] = result[i] + " " + result[i + 1];
-                }
-                else {
-                    result[i - 1] = result[i - 1] + " " + result[i];
-                }
-                result.splice(i, 1);
-                changed = true;
-                break;
-            }
-        }
-    }
-    return result;
-}
-/** Tie-break when two merge candidates are both {@link bucketsMergeCompatible} (same bucket or COMPATIBLE_BUCKET_SETS). */
-function capMergePenalty(leftBucket, rightBucket) {
-    if (leftBucket === rightBucket) {
-        return 0;
-    }
-    if (bucketsCompatible(leftBucket, rightBucket)) {
-        return 0;
-    }
-    return 500;
-}
-/**
- * Merge adjacent groups until total count ≤ maxGroups.
- * Only merges pairs allowed by {@link bucketsMergeCompatible} — never glues incompatible
- * buckets (which previously defaulted to penalty 0 and merged layout+state when over cap).
- *
- * Complexity: O(n²) in the number of groups — each merge pass scans all remaining adjacent
- * pairs. In practice `n` is bounded by {@link MAX_GROUPS_CAP} (24) and typical class strings
- * are well below that, so this is not a concern for the current usage pattern. If this ever
- * runs in a high-throughput batch mode, consider a priority-queue approach.
- */
-export function capGroups(groups, maxGroups) {
-    const result = [...groups];
-    const lengths = result.map((groupStr) => tokenizeClassString(groupStr).length);
-    while (result.length > maxGroups) {
-        const mergePairCandidates = [];
-        for (let i = 0; i < result.length - 1; i++) {
-            const dominantLeft = dominantBucketOfGroup(result[i]);
-            const dominantRight = dominantBucketOfGroup(result[i + 1]);
-            if (!bucketsMergeCompatible(dominantLeft, dominantRight)) {
-                continue;
-            }
-            mergePairCandidates.push({
-                i,
-                size: lengths[i] + lengths[i + 1],
-                penalty: capMergePenalty(dominantLeft, dominantRight),
-            });
-        }
-        if (mergePairCandidates.length === 0) {
-            break;
-        }
-        let best = mergePairCandidates[0];
-        for (const candidate of mergePairCandidates) {
-            if (candidate.penalty < best.penalty ||
-                (candidate.penalty === best.penalty && candidate.size < best.size)) {
-                best = candidate;
-            }
-        }
-        const bestIdx = best.i;
-        result[bestIdx] = result[bestIdx] + " " + result[bestIdx + 1];
-        lengths[bestIdx] = lengths[bestIdx] + lengths[bestIdx + 1];
-        result.splice(bestIdx + 1, 1);
-        lengths.splice(bestIdx + 1, 1);
-    }
-    return result;
-}
-/**
- * If a chunk is **only** bare `ease-*` timing (Motion), buffer it and prepend to the **first**
- * **later** chunk that is predominantly `state` **and** contains some `animate-*` utility —
- * skipping intermediate `state` chunks (`sm:…`, `group-data-[…]:…`, etc.) that sit between
- * `ease-ui` and `data-open:animate-*`. If no such chunk exists, the ease chunk is left as-is.
- */
-export function mergeEaseTimingIntoFollowingAnimatedState(groups) {
-    const result = [...groups];
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (let i = 0; i < result.length; i++) {
-            if (!chunkIsOnlyEaseTimingMotion(result[i])) {
-                continue;
-            }
-            const easeStr = result[i];
-            let target = -1;
-            for (let j = i + 1; j < result.length; j++) {
-                if (dominantBucketOfGroup(result[j]) !== "state") {
-                    continue;
-                }
-                const classTokens = tokenizeClassString(result[j]);
-                if (!classTokens.some((classToken) => /^animate/.test(stripVariants(classToken)))) {
-                    continue;
-                }
-                target = j;
-                break;
-            }
-            if (target === -1) {
-                continue;
-            }
-            result[target] = `${easeStr} ${result[target]}`.trim();
-            result.splice(i, 1);
-            changed = true;
-            break;
-        }
-    }
-    return result;
-}
-function chunkIsOnlyEaseTimingMotion(groupStr) {
-    const classTokens = tokenizeClassString(groupStr);
-    if (classTokens.length === 0) {
-        return false;
-    }
-    return classTokens.every((classToken) => classifyToken(classToken) === "motion" && /^ease-/.test(stripVariants(classToken)));
-}
-export function suggestCnGroups(classString) {
-    const tokens = tokenizeClassString(classString);
-    if (tokens.length === 0) {
-        return [];
-    }
-    const classified = tokens.map((classToken, index) => ({
-        classToken,
-        bucket: classifyToken(classToken),
-        index,
-    }));
-    classified.sort((left, right) => {
-        const bucketOrderDiff = BUCKET_ORDER[left.bucket] - BUCKET_ORDER[right.bucket];
-        if (bucketOrderDiff !== 0) {
-            return bucketOrderDiff;
-        }
-        if (left.bucket === "composite" && right.bucket === "composite") {
-            const compositeOrderDiff = compositeSecondaryOrder(stripVariants(left.classToken)) -
-                compositeSecondaryOrder(stripVariants(right.classToken));
-            if (compositeOrderDiff !== 0) {
-                return compositeOrderDiff;
-            }
-        }
-        return left.index - right.index;
-    });
-    const rawGroups = [];
-    /** Bucket of the last token already placed in the current run (pairwise compat with `COMPATIBLE_BUCKET_SETS`). */
-    let lastBucketInRun = null;
-    let currentStateKey = null;
-    let currentTokens = [];
-    const flush = () => {
-        if (currentTokens.length > 0) {
-            rawGroups.push(currentTokens.join(" "));
-            currentTokens = [];
-        }
-        lastBucketInRun = null;
-        currentStateKey = null;
-    };
-    for (const { classToken, bucket: tokenBucket } of classified) {
-        if (lastBucketInRun === null) {
-            lastBucketInRun = tokenBucket;
-            currentStateKey = isVariantKeyedBucket(tokenBucket)
-                ? variantGroupKey(tokenBucket, classToken)
-                : null;
-            currentTokens.push(classToken);
-            continue;
-        }
-        if (isVariantKeyedBucket(tokenBucket)) {
-            const key = variantGroupKey(tokenBucket, classToken);
-            if (currentStateKey !== null && key !== currentStateKey) {
-                flush();
-                lastBucketInRun = tokenBucket;
-                currentStateKey = key;
-                currentTokens.push(classToken);
-                continue;
-            }
-        }
-        if (!bucketsCompatible(tokenBucket, lastBucketInRun)) {
-            flush();
-            lastBucketInRun = tokenBucket;
-            currentStateKey = isVariantKeyedBucket(tokenBucket)
-                ? variantGroupKey(tokenBucket, classToken)
-                : null;
-            currentTokens.push(classToken);
-            continue;
-        }
-        if (isVariantKeyedBucket(tokenBucket)) {
-            currentStateKey = variantGroupKey(tokenBucket, classToken);
-        }
-        else if (currentStateKey !== null) {
-            // Defensive reset: keeps state-key logic explicit if bucket rules evolve.
-            currentStateKey = null;
-        }
-        lastBucketInRun = tokenBucket;
-        currentTokens.push(classToken);
-    }
-    flush();
-    const merged = mergeSingletons(rawGroups);
-    const withEaseMerged = mergeEaseTimingIntoFollowingAnimatedState(merged);
-    // Never cap-merge below the semantic chunk count from the tokenizer (fixes layout+state glued
-    // when `preferred` compat list was empty and unrelated pairs used penalty 0).
-    const maxAllowed = Math.max(dynamicMaxGroups(tokens.length), withEaseMerged.length);
-    return capGroups(withEaseMerged, maxAllowed);
-}
-/**
- * One label per suggested group: a single bucket name, or `mixed:a+b` when that chunk
- * spans multiple Tailwind buckets (matches `codefast arrange group` stdout).
- */
-export function summarizeGroupBucketLabels(groups) {
-    return groups.map((g) => {
-        const uniq = new Set(tokenizeClassString(g).map(classifyToken));
-        return uniq.size === 1 ? [...uniq][0] : `mixed:${[...uniq].sort().join("+")}`;
-    });
-}

package/dist/lib/arrange/domain/imports.d.ts

@@ -1,7 +0,0 @@
-import { type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
-/**
- * Resolve the module specifier used when injecting a `cn` import into a file.
- */
-export declare function cnModuleSpecifierForFile(filePath: string, override?: string): string;
-export declare function ensureCnImport(sourceFile: DomainSourceFile, cnImportOverride?: string): string;
-//# sourceMappingURL=imports.d.ts.map

package/dist/lib/arrange/domain/imports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/imports.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAItB,MAAM,wCAAwC,CAAC;AAsBhD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAMpF;AAeD,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CA2C9F"}

package/dist/lib/arrange/domain/imports.js

@@ -1,80 +0,0 @@
-import { isDomainImportDeclaration, isDomainNamedImports, isDomainStringLiteral, } from "#lib/arrange/domain/ast/ast-node.model";
-function sourceFileImportsCn(sourceFile) {
-    for (const statement of sourceFile.statements) {
-        if (!isDomainImportDeclaration(statement) || !statement.importClause) {
-            continue;
-        }
-        const clause = statement.importClause;
-        if (clause.name?.text === "cn") {
-            return true;
-        }
-        if (clause.namedBindings && isDomainNamedImports(clause.namedBindings)) {
-            for (const importedBinding of clause.namedBindings.elements) {
-                if (importedBinding.name.text === "cn") {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-/**
- * Resolve the module specifier used when injecting a `cn` import into a file.
- */
-export function cnModuleSpecifierForFile(filePath, override) {
-    void filePath;
-    if (override) {
-        return override;
-    }
-    return "@codefast/tailwind-variants";
-}
-function findImportDeclarationFromModule(sourceFile, moduleSpecifier) {
-    for (const statement of sourceFile.statements) {
-        if (!isDomainImportDeclaration(statement)) {
-            continue;
-        }
-        const spec = statement.moduleSpecifier;
-        if (isDomainStringLiteral(spec) && spec.text === moduleSpecifier) {
-            return statement;
-        }
-    }
-    return undefined;
-}
-export function ensureCnImport(sourceFile, cnImportOverride) {
-    const sourceText = sourceFile.text;
-    if (sourceFileImportsCn(sourceFile)) {
-        return sourceText;
-    }
-    const moduleSpecifier = cnModuleSpecifierForFile(sourceFile.fileName, cnImportOverride);
-    const decl = findImportDeclarationFromModule(sourceFile, moduleSpecifier);
-    if (decl?.importClause &&
-        !decl.importClause.isTypeOnly &&
-        decl.importClause.namedBindings &&
-        isDomainNamedImports(decl.importClause.namedBindings)) {
-        const elements = decl.importClause.namedBindings.elements;
-        if (elements.length > 0) {
-            const pos = elements[0].pos;
-            return `${sourceText.slice(0, pos)}cn, ${sourceText.slice(pos)}`;
-        }
-    }
-    const importLine = `import { cn } from "${moduleSpecifier}";`;
-    let firstImport = -1;
-    for (const statement of sourceFile.statements) {
-        if (isDomainImportDeclaration(statement)) {
-            firstImport = statement.pos;
-            break;
-        }
-    }
-    const useClient = /^["']use client["'];?\s*\r?\n/.exec(sourceText);
-    let insertAt;
-    if (useClient) {
-        insertAt = useClient[0].length;
-    }
-    else if (firstImport !== -1) {
-        insertAt = firstImport;
-    }
-    else {
-        insertAt = 0;
-    }
-    return `${sourceText.slice(0, insertAt)}${importLine}\n${sourceText.slice(insertAt)}`;
-}

package/dist/lib/arrange/domain/source-text-formatters.d.ts

@@ -1,16 +0,0 @@
-export declare function escapeTsStringLiteralContent(group: string): string;
-/**
- * Multiline fragment for use *inside* an existing `cn(...)` — replaces one
- * string argument with several, without producing `cn(cn(...))`.
- */
-export declare function formatCnArguments(groups: string[], options?: {
-    indent?: string;
-    commaAfterLastGroup?: boolean;
-    trailingClassName?: boolean;
-}): string;
-export declare function formatCnCall(groups: string[], options?: {
-    trailingClassName?: boolean;
-}): string;
-export declare function formatArray(groups: string[]): string;
-export declare function formatJsxCnAttributeValue(groups: string[], source: string, valueNodeStart: number): string;
-//# sourceMappingURL=source-text-formatters.d.ts.map

package/dist/lib/arrange/domain/source-text-formatters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source-text-formatters.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/source-text-formatters.ts"],"names":[],"mappings":"AAEA,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,GACA,MAAM,CAaR;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAahG;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CASpD;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EAAE,EAChB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,GACrB,MAAM,CAQR"}

package/dist/lib/arrange/domain/source-text-formatters.js

@@ -1,55 +0,0 @@
-import { indentOfLineContaining } from "#lib/shared/source-code/domain/text-edit";
-export function escapeTsStringLiteralContent(group) {
-    return group.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
-}
-/**
- * Multiline fragment for use *inside* an existing `cn(...)` — replaces one
- * string argument with several, without producing `cn(cn(...))`.
- */
-export function formatCnArguments(groups, options) {
-    const indent = options?.indent ?? "  ";
-    const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
-    const lines = [];
-    for (let i = 0; i < groups.length; i++) {
-        const group = groups[i];
-        const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
-        lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
-    }
-    if (options?.trailingClassName) {
-        lines.push(`${indent}className,`);
-    }
-    return lines.join("\n");
-}
-export function formatCnCall(groups, options) {
-    const lines = ["cn("];
-    const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
-    for (let i = 0; i < groups.length; i++) {
-        const group = groups[i];
-        const comma = commaOnEachStringLine ? "," : "";
-        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
-    }
-    if (options?.trailingClassName) {
-        lines.push("  className,");
-    }
-    lines.push(")");
-    return lines.join("\n");
-}
-export function formatArray(groups) {
-    const lines = ["["];
-    for (let i = 0; i < groups.length; i++) {
-        const group = groups[i];
-        const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
-        lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
-    }
-    lines.push("]");
-    return lines.join("\n");
-}
-export function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
-    const baseIndent = indentOfLineContaining(source, valueNodeStart);
-    const argIndent = `${baseIndent}  `;
-    const cnArgumentsBlock = formatCnArguments(groups, {
-        indent: argIndent,
-        commaAfterLastGroup: groups.length > 1,
-    });
-    return `{cn(\n${cnArgumentsBlock}\n${baseIndent})}`;
-}

package/dist/lib/arrange/domain/tokenizer.d.ts

@@ -1,45 +0,0 @@
-import type { Bucket } from "#lib/arrange/domain/types";
-export declare function tokenizeClassString(classString: string): string[];
-/**
- * Index of the first `:` that separates a Tailwind variant segment from the rest.
- * Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
- * `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
- */
-export declare function indexOfFirstVariantColon(text: string): number;
-export declare function stripVariants(token: string): string;
-/**
- * Secondary sort inside the **composite** bucket: opacity / blend / isolation →
- * 3D context → 3D transforms → 2D transforms → filters → will-change.
- */
-export declare function compositeSecondaryOrder(bareUtility: string): number;
-/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */
-export declare function classifyBareUtility(bareUtility: string): Bucket;
-/**
- * Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
- * scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
- * and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
- * Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
- */
-export declare function isArbitraryParentSelectorStateToken(token: string): boolean;
-export declare function classifyToken(token: string): Bucket;
-/**
- * Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
- * (`selector` uses {@link selectorKey}).
- * Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
- * outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
- * separate groups while `hover:opacity` still keys as `hover` + `opacity`…
- *
- * `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
- * {@link ariaAttributeStem} (full token required for bracket capture).
- */
-export declare function stateKey(token: string): string;
-/**
- * Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
- * Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
- * `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
- */
-export declare function selectorKey(token: string): string;
-export declare function bucketsCompatible(a: Bucket, b: Bucket): boolean;
-/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */
-export declare function bucketsMergeCompatible(a: Bucket, b: Bucket): boolean;
-//# sourceMappingURL=tokenizer.d.ts.map

package/dist/lib/arrange/domain/tokenizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/tokenizer.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AA4CxD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAa7D;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWnD;AA6FD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAiDnE;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAiK/D;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAa1E;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAmCnD;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsB9C;AAID;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKjD;AASD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAK/D;AAED,8GAA8G;AAC9G,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAcpE"}