@teacss/engine 0.9.3 → 0.10.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@teacss/engine",
-  "version": "0.9.3",
-  "description": "In-process Rust engine for TeaCSS 0.9 (napi-rs binding and 0.8.x-compatible facade)",
+  "version": "0.10.2",
+  "description": "In-process Rust engine for TeaCSS (napi-rs binding, contract types and the project helper the shells share)",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -21,14 +21,6 @@
       "types": "./binding.d.ts",
       "default": "./binding.js"
     },
-    "./facade": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./select": {
-      "types": "./dist/select.d.ts",
-      "default": "./dist/select.js"
-    },
     "./package.json": "./package.json"
   },
   "imports": {
@@ -41,11 +33,12 @@
     "binding-header.d.ts",
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "sideEffects": false,
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=26"
   },
   "napi": {
     "binaryName": "teacss-engine",
@@ -59,45 +52,23 @@
       "aarch64-unknown-linux-gnu",
       "aarch64-unknown-linux-musl",
       "x86_64-pc-windows-msvc",
-      "aarch64-pc-windows-msvc",
-      "wasm32-wasip1-threads"
+      "aarch64-pc-windows-msvc"
     ]
   },
-  "engineCompat": {
-    "core": ">=0.8.5 <0.10.0",
-    "defaultMode": "auto",
-    "oracle": {
-      "teacssTs": "0.8.5",
-      "commit": "786b4d40"
-    }
-  },
   "optionalDependencies": {
-    "@teacss/engine-darwin-arm64": "0.9.3",
-    "@teacss/engine-darwin-x64": "0.9.3",
-    "@teacss/engine-linux-arm64-gnu": "0.9.3",
-    "@teacss/engine-linux-arm64-musl": "0.9.3",
-    "@teacss/engine-linux-x64-gnu": "0.9.3",
-    "@teacss/engine-linux-x64-musl": "0.9.3",
-    "@teacss/engine-win32-arm64-msvc": "0.9.3",
-    "@teacss/engine-win32-x64-msvc": "0.9.3"
-  },
-  "peerDependencies": {
-    "@teacss/config": ">=0.8.5 <0.10.0 || >=0.9.0-alpha.0 <0.10.0",
-    "@teacss/core": ">=0.8.5 <0.10.0 || >=0.9.0-alpha.0 <0.10.0"
-  },
-  "peerDependenciesMeta": {
-    "@teacss/core": {
-      "optional": true
-    },
-    "@teacss/config": {
-      "optional": true
-    }
+    "@teacss/engine-darwin-arm64": "0.10.2",
+    "@teacss/engine-darwin-x64": "0.10.2",
+    "@teacss/engine-linux-arm64-gnu": "0.10.2",
+    "@teacss/engine-linux-arm64-musl": "0.10.2",
+    "@teacss/engine-linux-x64-gnu": "0.10.2",
+    "@teacss/engine-linux-x64-musl": "0.10.2",
+    "@teacss/engine-win32-arm64-msvc": "0.10.2",
+    "@teacss/engine-win32-x64-msvc": "0.10.2"
   },
   "devDependencies": {
     "@napi-rs/cli": "3.10.8",
     "@types/node": "^22.20.5",
     "emnapi": "1.11.3",
-    "magic-string": "^0.30.17",
     "typescript": "^5.9.3"
   },
   "scripts": {
@@ -107,12 +78,12 @@
     "artifacts": "napi artifacts --output-dir ../../artifacts --npm-dir npm",
     "create-npm-dirs": "napi create-npm-dirs",
     "prepublishOnly": "npm run build:ts && node build/scripts/check-publish.js",
-    "test": "npm run build:ts && npm run check:types && node --expose-gc --test \"build/test/**/*.test.js\"",
+    "test": "npm run build:ts && npm run check:types && node --expose-gc --test \"build/tests/**/*.test.js\"",
     "check:version": "npm run build:ts && node build/scripts/sync-version.js --check",
     "check:size": "node build/scripts/size-budget.js",
-    "version": "napi version && npm run build:ts && node build/scripts/sync-version.js --write && git add npm/*/package.json package-lock.json ../../Cargo.toml ../../Cargo.lock ../../package-lock.json",
-    "build:ts": "tsc -p tsconfig.json && tsc -p tsconfig.test.json",
-    "check:types": "tsc -p test/consumer/tsconfig.json --noEmit",
+    "version": "napi version && npm run build:ts && node build/scripts/sync-version.js --write && git add -- npm/*/package.json package-lock.json ../*/package.json ../*/npm/*/package.json ../*/package-lock.json ../../Cargo.toml ../../Cargo.lock ../../extensions/zed/Cargo.toml ../../extensions/zed/extension.toml ../../extensions/zed/Cargo.lock ../../package-lock.json",
+    "build:ts": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.test.json",
+    "check:types": "tsc -p tests/consumer/tsconfig.json --noEmit",
     "check:publish": "node build/scripts/check-publish.js",
     "check:tag": "node build/scripts/check-tag.js",
     "inspect-binding": "node build/scripts/inspect-binding.js",
@@ -122,8 +93,7 @@
     "release:evidence": "node build/scripts/release-evidence.js",
     "publish:npm": "node build/scripts/publish.js",
     "dist-tag": "node build/scripts/dist-tag.js",
-    "qualify": "node build/scripts/qualify.js",
-    "setup-wasi-sdk": "node build/scripts/setup-wasi-sdk.js"
+    "qualify": "node build/scripts/qualify.js"
   },
   "publishConfig": {
     "access": "public",

package/dist/config-view.d.ts

@@ -1,36 +0,0 @@
-/** Fields the TypeScript generator provides; reading one before materialize throws `E_TS_REQUIRED`. */
-export declare const TS_ONLY_FIELDS: readonly string[];
-/** Fields copied from the Rust `ResolvedConfigView`. */
-export declare const VIEW_FIELDS: readonly string[];
-export interface ConfigViewArgs {
-    view: Record<string, any>;
-    request: object;
-    presets: object[];
-    /** The merged config (`mergeDefinedConfig(defaults, userConfig)`, config.ts:210) the oracle spreads. */
-    merged: Record<string, unknown>;
-    transformers: object[];
-    host: {
-        core?: {
-            extractorSplit: object;
-        } | undefined;
-    };
-    fallback: {
-        peek(): {
-            config: Record<string, unknown>;
-        } | null;
-    };
-    engine?: {
-        compileClassShortcuts(): unknown[];
-    };
-}
-/**
- * The merged `content.pipeline` of the presets and the config, as `mergeContentOptions`
- * (core/config.ts) builds it: `false` anywhere disables it, otherwise includes and excludes
- * concatenate in source order without duplicates. The runtime builds its module filter from it.
- */
-export declare function mergePipeline(sources: readonly unknown[]): false | {
-    include?: Array<string | RegExp>;
-    exclude?: Array<string | RegExp>;
-} | undefined;
-export declare function createConfigView({ view, presets, merged, transformers, host, fallback, engine }: ConfigViewArgs): Record<string, unknown>;
-//# sourceMappingURL=config-view.d.ts.map

package/dist/config-view.js

@@ -1,135 +0,0 @@
-// The facade's `generator.config`: a plain object whose keys follow the oracle `resolveConfig`
-// (core/config.ts:260-288), which spreads the merged config and then sets its own fields.
-import { tsNotReadyError } from "./errors.js";
-/** Fields the TypeScript generator provides; reading one before materialize throws `E_TS_REQUIRED`. */
-export const TS_ONLY_FIELDS = Object.freeze(["configResolved", "extendTheme", "preprocess", "postprocess", "preflights", "autocomplete", "rules", "rulesDynamic", "rulesStaticMap", "variants"]);
-/** Fields copied from the Rust `ResolvedConfigView`. */
-export const VIEW_FIELDS = Object.freeze(["layers", "theme", "shortcuts", "safelist", "blocklist", "separators", "envMode", "unmatched", "shortcutsLayer", "virtualModulePrefix", "mergeSelectors", "warn", "details", "outputToCssLayers", "rulesSize"]);
-/**
- * The keys `resolveConfig` always sets, in its order (config.ts:262-288); `configResolved`,
- * `extendTheme`, `extractorDefault` and `virtualModulePrefix` appear only through the spread.
- */
-const RESOLVED_KEYS = Object.freeze([
-    "mergeSelectors",
-    "warn",
-    "unmatched",
-    "outputToCssLayers",
-    "sortLayers",
-    "blocklist",
-    "presets",
-    "envMode",
-    "shortcutsLayer",
-    "layers",
-    "theme",
-    "rules",
-    "rulesSize",
-    "rulesDynamic",
-    "rulesStaticMap",
-    "preprocess",
-    "postprocess",
-    "preflights",
-    "autocomplete",
-    "variants",
-    "shortcuts",
-    "extractors",
-    "safelist",
-    "separators",
-    "details",
-    "content",
-    "transformers",
-]);
-const ownValue = (source, key) => (source !== null && typeof source === "object" && Object.hasOwn(source, key) ? source[key] : undefined);
-const flattenPatterns = (patterns) => [...new Set(patterns.flatMap((pattern) => (Array.isArray(pattern) ? pattern : pattern ? [pattern] : [])))];
-/**
- * The merged `content.pipeline` of the presets and the config, as `mergeContentOptions`
- * (core/config.ts) builds it: `false` anywhere disables it, otherwise includes and excludes
- * concatenate in source order without duplicates. The runtime builds its module filter from it.
- */
-export function mergePipeline(sources) {
-    const includes = [];
-    const excludes = [];
-    let configured = false;
-    for (const content of new Set(sources.map((source) => ownValue(source, "content")).filter((content) => content !== undefined && content !== null))) {
-        const pipeline = ownValue(content, "pipeline");
-        if (pipeline === false)
-            return false;
-        if (pipeline === undefined)
-            continue;
-        configured = true;
-        const include = pipeline && ownValue(pipeline, "include");
-        const exclude = pipeline && ownValue(pipeline, "exclude");
-        if (include)
-            includes.push(include);
-        if (exclude)
-            excludes.push(exclude);
-    }
-    if (!configured)
-        return undefined;
-    const merged = {};
-    if (includes.length)
-        merged.include = flattenPatterns(includes);
-    if (excludes.length)
-        merged.exclude = flattenPatterns(excludes);
-    return merged;
-}
-export function createConfigView({ view, presets, merged, transformers, host, fallback, engine }) {
-    const config = {};
-    const data = (key, value) => Object.defineProperty(config, key, { value, enumerable: true, configurable: true, writable: true });
-    const tsOnly = (key) => Object.defineProperty(config, key, {
-        enumerable: true,
-        configurable: true,
-        get() {
-            const ts = fallback.peek();
-            if (!ts)
-                throw tsNotReadyError(`config.${key}`);
-            return ts.config[key];
-        },
-    });
-    const extractors = host.core ? [host.core.extractorSplit] : [{ name: view.extractors?.[0]?.name ?? "@teacss/core/extractor-split" }];
-    const fields = {
-        presets: () => data("presets", presets),
-        content: () => {
-            const pipeline = mergePipeline([...presets, merged]);
-            data("content", pipeline === undefined ? (view.content ?? {}) : { pipeline, ...view.content });
-        },
-        transformers: () => data("transformers", transformers),
-        extractors: () => data("extractors", extractors),
-        extractorDefault: () => data("extractorDefault", extractors[0]),
-        sortLayers: () => data("sortLayers", (layers) => layers),
-    };
-    for (const key of VIEW_FIELDS)
-        fields[key] = () => data(key, view[key]);
-    // config.ts:263. Rust never warns, so its view does not carry the option.
-    fields.warn = () => data("warn", (Object.hasOwn(merged, "warn") ? merged.warn : undefined) ?? true);
-    if (engine) {
-        // compile-class.ts:84-106 pushes each definition onto `config.shortcuts` and splices it out
-        // when its last module drops it; the definitions live in the Engine, so one array is kept in
-        // step on every read.
-        const shortcuts = [...(view.shortcuts ?? [])];
-        const configured = shortcuts.length;
-        fields.shortcuts = () => Object.defineProperty(config, "shortcuts", {
-            enumerable: true,
-            configurable: true,
-            get() {
-                shortcuts.length = configured;
-                shortcuts.push(...engine.compileClassShortcuts());
-                return shortcuts;
-            },
-        });
-    }
-    for (const key of TS_ONLY_FIELDS)
-        fields[key] = () => tsOnly(key);
-    for (const key of Object.keys(merged)) {
-        if (key === "engine")
-            continue;
-        if (Object.hasOwn(fields, key))
-            fields[key]();
-        else
-            data(key, merged[key]);
-    }
-    // Redefining a spread key keeps its position, as the object literal does.
-    for (const key of RESOLVED_KEYS)
-        fields[key]();
-    return config;
-}
-//# sourceMappingURL=config-view.js.map

package/dist/constants.d.ts

@@ -1,22 +0,0 @@
-/** `@teacss/engine`'s own package.json version; the facade `generator.version` without a host. */
-export declare const ENGINE_PACKAGE_VERSION: string;
-/** `package.json#engineCompat` (v02.11 §7.3); without it `core` is unrestricted and `defaultMode` is `"auto"`. */
-export declare const ENGINE_COMPAT: Readonly<{
-    core: string | undefined;
-    defaultMode: "opt-in" | "auto";
-    oracle: {
-        teacssTs: string;
-        commit: string;
-    } | undefined;
-}>;
-export declare const ENGINE_INSTANCE: unique symbol;
-export declare const ENGINE_MATERIALIZE: unique symbol;
-export declare const ENGINE_STATS: unique symbol;
-export declare const PRESET_OPTIONS: Readonly<{
-    standard: symbol;
-    icons: symbol;
-    official: symbol;
-}>;
-export declare const CONFIG_SOURCE_DECLARATIONS: unique symbol;
-export declare const CONFIG_ENTRY_PROVENANCE: unique symbol;
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,23 +0,0 @@
-// The facade's symbols and package constants. It imports nothing from the facade, so every
-// facade module can import it without a cycle through `index.ts`.
-import { createRequire } from "node:module";
-const pkg = createRequire(import.meta.url)("../package.json");
-/** `@teacss/engine`'s own package.json version; the facade `generator.version` without a host. */
-export const ENGINE_PACKAGE_VERSION = pkg.version;
-/** `package.json#engineCompat` (v02.11 §7.3); without it `core` is unrestricted and `defaultMode` is `"auto"`. */
-export const ENGINE_COMPAT = Object.freeze({
-    core: pkg.engineCompat?.core,
-    defaultMode: pkg.engineCompat?.defaultMode ?? "auto",
-    oracle: pkg.engineCompat?.oracle,
-});
-export const ENGINE_INSTANCE = Symbol.for("@teacss/engine/instance");
-export const ENGINE_MATERIALIZE = Symbol.for("@teacss/engine/materialize");
-export const ENGINE_STATS = Symbol.for("@teacss/engine/stats");
-export const PRESET_OPTIONS = Object.freeze({
-    standard: Symbol.for("@teacss/preset-standard/options"),
-    icons: Symbol.for("@teacss/preset-icons/options"),
-    official: Symbol.for("@teacss/preset-official/options"),
-});
-export const CONFIG_SOURCE_DECLARATIONS = Symbol.for("@teacss/config/source-declarations");
-export const CONFIG_ENTRY_PROVENANCE = Symbol.for("@teacss/config/entry-provenance");
-//# sourceMappingURL=constants.js.map

package/dist/countable-set.d.ts

@@ -1,57 +0,0 @@
-export declare const MAX_RUNTIME_CACHE_ENTRIES = 10000;
-export declare class CountableSet<K> extends Set<K> {
-    _map: Map<K, number>;
-    constructor(values?: Iterable<K>);
-    add(key: K): this;
-    delete(key: K): boolean;
-    clear(): void;
-    getCount(key: K): number;
-    setCount(key: K, count: number): this;
-}
-export declare function isCountableSet(value: unknown): value is CountableSet<string>;
-export declare function copyCountableSet<K>(input: CountableSet<K>): CountableSet<K>;
-/**
- * Expands the tokens holding a `{…}` group in place; the parts go to the end, and a counted
- * group's count carries over to each part.
- */
-export declare function expandInputGroups<T extends Set<string>>(tokens: T): T;
-/**
- * The part of the oracle `BoundedMap` the facade uses: ordinary keys are evicted oldest first,
- * retained keys never count toward the limit. An entry can be pending (`setPending`,
- * `replaceRetainedPending`): its value is `resolve(token)`, computed on the first read through
- * `get`, `forEach` or iteration and kept in place; `has`, `size`, `delete` and eviction never
- * resolve.
- */
-export declare class BoundedTokenCache<V> extends Map<string, V> {
-    #private;
-    maxEntries: number;
-    retained: Set<string>;
-    /** Ordinary keys in insertion order, the order the native map iterates them. */
-    order: Set<string>;
-    /** The value of a pending entry, called once per entry on its first read. */
-    resolve: (token: string) => V;
-    constructor(maxEntries?: number, resolve?: (token: string) => V);
-    get retainedSize(): number;
-    isRetained(key: string): boolean;
-    get(key: string): V | undefined;
-    entries(): MapIterator<[string, V]>;
-    values(): MapIterator<V>;
-    [Symbol.iterator](): MapIterator<[string, V]>;
-    forEach(callback: (value: V, key: string, map: Map<string, V>) => void, thisArg?: unknown): void;
-    set(key: string, value: V): this;
-    /** Caches `key` with the value `resolve` supplies on its first read. */
-    setPending(key: string): this;
-    delete(key: string): boolean;
-    clear(): void;
-    /** Replaces the retained entries (bounded-cache.ts:188-205 without the revision check). */
-    replaceRetained(entries: Iterable<readonly [string, V]>): void;
-    /** `replaceRetained` with every value pending. */
-    replaceRetainedPending(keys: Iterable<string>): void;
-}
-/** FIFO bounded Set (the oracle `BoundedSet` without its `assumeNoPrototypeBypass` fast path). */
-export declare class BoundedSet extends Set<string> {
-    maxEntries: number;
-    constructor(maxEntries?: number, values?: Iterable<string>);
-    add(value: string): this;
-}
-//# sourceMappingURL=countable-set.d.ts.map

package/dist/countable-set.js

@@ -1,205 +0,0 @@
-// Token collections the facade shares with `@teacss/core`: CountableSet (core/utils/countable-set.ts),
-// expandInputGroups (core/generator.ts:517-535) and the FIFO caches of core/bounded-cache.ts.
-import { expandClassGroups, splitClassTokens } from "../binding.js";
-export const MAX_RUNTIME_CACHE_ENTRIES = 10_000;
-export class CountableSet extends Set {
-    _map = new Map();
-    constructor(values) {
-        super();
-        if (values)
-            for (const key of values)
-                this.add(key);
-    }
-    add(key) {
-        this._map.set(key, (this._map.get(key) ?? 0) + 1);
-        return super.add(key);
-    }
-    delete(key) {
-        if (!this._map.has(key))
-            return false;
-        this._map.delete(key);
-        return super.delete(key);
-    }
-    clear() {
-        this._map.clear();
-        super.clear();
-    }
-    getCount(key) {
-        return this._map.get(key) ?? 0;
-    }
-    setCount(key, count) {
-        this._map.set(key, count);
-        return super.add(key);
-    }
-}
-export function isCountableSet(value) {
-    return value instanceof CountableSet;
-}
-export function copyCountableSet(input) {
-    const copied = new CountableSet();
-    for (const key of input)
-        copied.setCount(key, input.getCount(key));
-    return copied;
-}
-/**
- * Expands the tokens holding a `{…}` group in place; the parts go to the end, and a counted
- * group's count carries over to each part.
- */
-export function expandInputGroups(tokens) {
-    const expanded = [...tokens].filter((token) => token.includes("{"));
-    if (expanded.length === 0)
-        return tokens;
-    for (const token of expanded) {
-        const parts = splitClassTokens(expandClassGroups(token));
-        if (parts.length === 1 && parts[0] === token)
-            continue;
-        const count = isCountableSet(tokens) ? tokens.getCount(token) : 1;
-        tokens.delete(token);
-        for (const part of parts) {
-            if (isCountableSet(tokens))
-                tokens.setCount(part, tokens.getCount(part) + count);
-            else
-                tokens.add(part);
-        }
-    }
-    return tokens;
-}
-/** The value of an entry whose token has not been resolved yet; never a valid `V`. */
-const PENDING = Symbol("@teacss/engine/pending");
-function noResolver(token) {
-    throw new TypeError(`[@teacss/engine] pending cache entry "${token}" has no resolver`);
-}
-/**
- * The part of the oracle `BoundedMap` the facade uses: ordinary keys are evicted oldest first,
- * retained keys never count toward the limit. An entry can be pending (`setPending`,
- * `replaceRetainedPending`): its value is `resolve(token)`, computed on the first read through
- * `get`, `forEach` or iteration and kept in place; `has`, `size`, `delete` and eviction never
- * resolve.
- */
-export class BoundedTokenCache extends Map {
-    constructor(maxEntries = MAX_RUNTIME_CACHE_ENTRIES, resolve = noResolver) {
-        super();
-        this.maxEntries = maxEntries;
-        this.retained = new Set();
-        this.order = new Set();
-        this.resolve = resolve;
-    }
-    get retainedSize() {
-        return this.retained.size;
-    }
-    isRetained(key) {
-        return this.retained.has(key);
-    }
-    get(key) {
-        const stored = super.get(key);
-        return stored === PENDING ? this.#materialize(key) : stored;
-    }
-    *entries() {
-        for (const [key, stored] of super.entries())
-            yield [key, this.#value(key, stored)];
-    }
-    *values() {
-        for (const [key, stored] of super.entries())
-            yield this.#value(key, stored);
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    forEach(callback, thisArg) {
-        for (const [key, value] of this.entries())
-            callback.call(thisArg, value, key, this);
-    }
-    set(key, value) {
-        return this.#insert(key, value);
-    }
-    /** Caches `key` with the value `resolve` supplies on its first read. */
-    setPending(key) {
-        return this.#insert(key, PENDING);
-    }
-    delete(key) {
-        const deleted = super.delete(key);
-        this.order.delete(key);
-        this.retained.delete(key);
-        return deleted;
-    }
-    clear() {
-        super.clear();
-        this.order.clear();
-        this.retained.clear();
-    }
-    /** Replaces the retained entries (bounded-cache.ts:188-205 without the revision check). */
-    replaceRetained(entries) {
-        this.#replaceRetained(new Map(entries));
-    }
-    /** `replaceRetained` with every value pending. */
-    replaceRetainedPending(keys) {
-        const next = new Map();
-        for (const key of keys)
-            next.set(key, PENDING);
-        this.#replaceRetained(next);
-    }
-    #value(key, stored) {
-        return stored === PENDING ? this.#materialize(key) : stored;
-    }
-    #materialize(key) {
-        const value = this.resolve(key);
-        super.set(key, value);
-        return value;
-    }
-    #insert(key, value) {
-        const exists = super.has(key);
-        this.#store(key, value);
-        if (!exists && !this.retained.has(key))
-            this.order.add(key);
-        this.#enforceLimit();
-        return this;
-    }
-    #replaceRetained(next) {
-        for (const key of this.retained) {
-            if (next.has(key))
-                continue;
-            super.delete(key);
-            this.retained.delete(key);
-        }
-        for (const [key, value] of next) {
-            this.order.delete(key);
-            this.#store(key, value);
-            this.retained.add(key);
-        }
-        this.#enforceLimit();
-    }
-    /** The marker is stored as a `V`; every read path above resolves it before a caller sees it. */
-    #store(key, value) {
-        super.set(key, value);
-    }
-    #enforceLimit() {
-        while (this.size - this.retained.size > this.maxEntries) {
-            const oldest = this.order.values().next();
-            if (oldest.done)
-                break;
-            this.order.delete(oldest.value);
-            super.delete(oldest.value);
-        }
-    }
-}
-/** FIFO bounded Set (the oracle `BoundedSet` without its `assumeNoPrototypeBypass` fast path). */
-export class BoundedSet extends Set {
-    constructor(maxEntries = MAX_RUNTIME_CACHE_ENTRIES, values) {
-        super();
-        this.maxEntries = maxEntries;
-        if (values)
-            for (const value of values)
-                this.add(value);
-    }
-    add(value) {
-        super.add(value);
-        while (this.size > this.maxEntries) {
-            const oldest = this.values().next();
-            if (oldest.done)
-                break;
-            super.delete(oldest.value);
-        }
-        return this;
-    }
-}
-//# sourceMappingURL=countable-set.js.map