textlane 0.0.0 → 0.2.0

package/build/generated/nl.d.ts

@@ -0,0 +1,99 @@
+import type { Plugin } from "../models/plugin.ts";
+/** `nl.parse`: natural language into nlcst. */
+export interface ParseOptions {
+    /** The rules sentences and words are found by. */
+    language?: Language;
+}
+/** The language `nl.parse` reads: parse-latin's rules, or parse-english's on top of them. */
+export type Language = "latin" | "english";
+/** `nl.equality`: warnings about insensitive, inconsiderate wording, as retext-equality; options are retext-equality's. */
+export interface EqualityOptions {
+    /** Phrases not to warn about. */
+    ignore?: string[] | null;
+    /** Whether a phrase used next to its counterpart (`he or she`) is fine. */
+    binary?: boolean | null;
+}
+/** `nl.passive`: warnings about the passive voice, as retext-passive; options are retext-passive's. */
+export interface PassiveOptions {
+    /** Participles not to warn about. */
+    ignore?: string[] | null;
+}
+/** `nl.readability`: warnings about sentences too hard to read, as retext-readability; options are retext-readability's. */
+export interface ReadabilityOptions {
+    /** The age of the target audience: 16 by default. */
+    age?: number | null;
+    /** The share of algorithms that must find a sentence too hard: 4/7 by default. */
+    threshold?: number | null;
+    /** The fewest words a sentence needs to be checked: 5 by default. */
+    minWords?: number | null;
+}
+/** `nl.sentenceSpacing`: warnings about the spaces between sentences, as retext-sentence-spacing; options are retext-sentence-spacing's. */
+export interface SentenceSpacingOptions {
+    /** The spacing expected between sentences: `1` or `"space"` (the default), `2` or `"double-space"`, `0` or `"newline"`. */
+    preferred?: Spacing | null;
+}
+/** A spacing between sentences, as a count of spaces or by name. */
+export type Spacing = number | string;
+/** `nl.smartypants`: straight quotes, dashes, dots and backticks into typographic ones; options as retext-smartypants takes them. */
+export interface SmartypantsOptions {
+    /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too, and needs `quotes: false`. */
+    backticks?: Backticks;
+    /** The closing quotes to use: `”` and `’` by default. */
+    closingQuotes?: QuoteCharacters | null;
+    /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */
+    dashes?: Dashes;
+    /** Turn three dots into an ellipsis, with spaces between them or without. */
+    ellipses?: Ellipses;
+    /** The opening quotes to use: `“` and `‘` by default. */
+    openingQuotes?: QuoteCharacters | null;
+    /** Turn straight quotes into smart ones. @default true */
+    quotes?: boolean | null;
+}
+export type Backticks = boolean | "all";
+/** The quote characters to use for double and single quotes. */
+export interface QuoteCharacters {
+    double: string;
+    single: string;
+}
+export type Dashes = boolean | "oldschool" | "inverted";
+export type Ellipses = boolean | "spaced" | "unspaced";
+/** `nl.quotes`: check that quotes and apostrophes are straight or smart, as preferred, at each level of nesting; options as retext-quotes takes them. */
+export interface QuotesOptions {
+    /** The style of quotes and apostrophes to prefer: `smart` by default. */
+    preferred?: QuoteStyle | null;
+    /** Smart quotes by nesting level, each one character or an opening and closing pair: `["“”", "‘’"]` by default. */
+    smart?: string[] | null;
+    /** Straight quotes by nesting level: `["\"", "'"]` by default. */
+    straight?: string[] | null;
+}
+/** A style of quotes: straight (`"`) or smart (`“”`). */
+export type QuoteStyle = "smart" | "straight";
+/** `nl.contractions`: check apostrophes in contractions, such as `don’t`; options as retext-contractions takes them. */
+export interface ContractionsOptions {
+    /** Also check contractions written as literals, such as `“hasnt”`. @default false */
+    allowLiterals?: boolean | null;
+    /** Expect straight apostrophes (`'`) instead of smart ones (`’`). @default false */
+    straight?: boolean | null;
+}
+/** The `nl.parse` plugin. */
+export declare function parse(options?: ParseOptions): Plugin<"nl.parse", ParseOptions>;
+/** The `nl.equality` plugin. */
+export declare function equality(options?: EqualityOptions): Plugin<"nl.equality", EqualityOptions>;
+/** The `nl.passive` plugin. */
+export declare function passive(options?: PassiveOptions): Plugin<"nl.passive", PassiveOptions>;
+/** The `nl.readability` plugin. */
+export declare function readability(options?: ReadabilityOptions): Plugin<"nl.readability", ReadabilityOptions>;
+/** The `nl.repeatedWords` plugin. */
+export declare function repeatedWords(): Plugin<"nl.repeatedWords">;
+/** The `nl.sentenceSpacing` plugin. */
+export declare function sentenceSpacing(options?: SentenceSpacingOptions): Plugin<"nl.sentenceSpacing", SentenceSpacingOptions>;
+/** The `nl.stringify` plugin. */
+export declare function stringify(): Plugin<"nl.stringify">;
+/** The `nl.smartypants` plugin. */
+export declare function smartypants(options?: SmartypantsOptions): Plugin<"nl.smartypants", SmartypantsOptions>;
+/** The `nl.quotes` plugin. */
+export declare function quotes(options?: QuotesOptions): Plugin<"nl.quotes", QuotesOptions>;
+/** The `nl.contractions` plugin. */
+export declare function contractions(options?: ContractionsOptions): Plugin<"nl.contractions", ContractionsOptions>;
+/** The `nl.indefiniteArticle` plugin. */
+export declare function indefiniteArticle(): Plugin<"nl.indefiniteArticle">;

package/build/generated/nl.js

@@ -0,0 +1,62 @@
+// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.
+/** The `nl.parse` plugin. */
+export function parse(options) {
+    if (options === undefined)
+        return { name: "nl.parse" };
+    return { name: "nl.parse", options };
+}
+/** The `nl.equality` plugin. */
+export function equality(options) {
+    if (options === undefined)
+        return { name: "nl.equality" };
+    return { name: "nl.equality", options };
+}
+/** The `nl.passive` plugin. */
+export function passive(options) {
+    if (options === undefined)
+        return { name: "nl.passive" };
+    return { name: "nl.passive", options };
+}
+/** The `nl.readability` plugin. */
+export function readability(options) {
+    if (options === undefined)
+        return { name: "nl.readability" };
+    return { name: "nl.readability", options };
+}
+/** The `nl.repeatedWords` plugin. */
+export function repeatedWords() {
+    return { name: "nl.repeatedWords" };
+}
+/** The `nl.sentenceSpacing` plugin. */
+export function sentenceSpacing(options) {
+    if (options === undefined)
+        return { name: "nl.sentenceSpacing" };
+    return { name: "nl.sentenceSpacing", options };
+}
+/** The `nl.stringify` plugin. */
+export function stringify() {
+    return { name: "nl.stringify" };
+}
+/** The `nl.smartypants` plugin. */
+export function smartypants(options) {
+    if (options === undefined)
+        return { name: "nl.smartypants" };
+    return { name: "nl.smartypants", options };
+}
+/** The `nl.quotes` plugin. */
+export function quotes(options) {
+    if (options === undefined)
+        return { name: "nl.quotes" };
+    return { name: "nl.quotes", options };
+}
+/** The `nl.contractions` plugin. */
+export function contractions(options) {
+    if (options === undefined)
+        return { name: "nl.contractions" };
+    return { name: "nl.contractions", options };
+}
+/** The `nl.indefiniteArticle` plugin. */
+export function indefiniteArticle() {
+    return { name: "nl.indefiniteArticle" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nl.js","sourceRoot":"","sources":["../../generated/nl.ts"],"names":[],"mappings":"AAAA,+EAA+E;AA+F/E,6BAA6B;AAC7B,MAAM,UAAU,KAAK,CAAC,OAAsB;IAC1C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAA;IACtD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,CAAA;AACtC,CAAC;AAED,gCAAgC;AAChC,MAAM,UAAU,QAAQ,CAAC,OAAyB;IAChD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAA;IACzD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA;AACzC,CAAC;AAED,+BAA+B;AAC/B,MAAM,UAAU,OAAO,CAAC,OAAwB;IAC9C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,CAAA;IACxD,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAA;AACxC,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,OAA4B;IACtD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAA;IAC5D,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAA;AAC5C,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,aAAa;IAC3B,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAA;AACrC,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,eAAe,CAAC,OAAgC;IAC9D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAA;IAChE,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,CAAA;AAChD,CAAC;AAED,iCAAiC;AACjC,MAAM,UAAU,SAAS;IACvB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAA;AACjC,CAAC;AAED,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,OAA4B;IACtD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAA;IAC5D,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAA;AAC5C,CAAC;AAED,8BAA8B;AAC9B,MAAM,UAAU,MAAM,CAAC,OAAuB;IAC5C,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAA;IACvD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAA;AACvC,CAAC;AAED,oCAAoC;AACpC,MAAM,UAAU,YAAY,CAAC,OAA6B;IACxD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAA;IAC7D,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAA;AAC7C,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,iBAAiB;IAC/B,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAA;AACzC,CAAC","sourcesContent":["// Generated by `pnpm generate:bindings` from the crate's plugins; do not edit.\n\nimport type { Plugin } from \"../models/plugin.ts\"\n\n/** `nl.parse`: natural language into nlcst. */\nexport interface ParseOptions {\n  /** The rules sentences and words are found by. */\n  language?: Language\n}\n\n/** The language `nl.parse` reads: parse-latin's rules, or parse-english's on top of them. */\nexport type Language = \"latin\" | \"english\"\n\n/** `nl.equality`: warnings about insensitive, inconsiderate wording, as retext-equality; options are retext-equality's. */\nexport interface EqualityOptions {\n  /** Phrases not to warn about. */\n  ignore?: string[] | null\n  /** Whether a phrase used next to its counterpart (`he or she`) is fine. */\n  binary?: boolean | null\n}\n\n/** `nl.passive`: warnings about the passive voice, as retext-passive; options are retext-passive's. */\nexport interface PassiveOptions {\n  /** Participles not to warn about. */\n  ignore?: string[] | null\n}\n\n/** `nl.readability`: warnings about sentences too hard to read, as retext-readability; options are retext-readability's. */\nexport interface ReadabilityOptions {\n  /** The age of the target audience: 16 by default. */\n  age?: number | null\n  /** The share of algorithms that must find a sentence too hard: 4/7 by default. */\n  threshold?: number | null\n  /** The fewest words a sentence needs to be checked: 5 by default. */\n  minWords?: number | null\n}\n\n/** `nl.sentenceSpacing`: warnings about the spaces between sentences, as retext-sentence-spacing; options are retext-sentence-spacing's. */\nexport interface SentenceSpacingOptions {\n  /** The spacing expected between sentences: `1` or `\"space\"` (the default), `2` or `\"double-space\"`, `0` or `\"newline\"`. */\n  preferred?: Spacing | null\n}\n\n/** A spacing between sentences, as a count of spaces or by name. */\nexport type Spacing = number | string\n\n/** `nl.smartypants`: straight quotes, dashes, dots and backticks into typographic ones; options as retext-smartypants takes them. */\nexport interface SmartypantsOptions {\n  /** Turn double backticks and double straight single quotes into double quotes; `all` turns single ones into single quotes too, and needs `quotes: false`. */\n  backticks?: Backticks\n  /** The closing quotes to use: `”` and `’` by default. */\n  closingQuotes?: QuoteCharacters | null\n  /** Turn two dashes into an em dash; `oldschool` and `inverted` treat three too. */\n  dashes?: Dashes\n  /** Turn three dots into an ellipsis, with spaces between them or without. */\n  ellipses?: Ellipses\n  /** The opening quotes to use: `“` and `‘` by default. */\n  openingQuotes?: QuoteCharacters | null\n  /** Turn straight quotes into smart ones. @default true */\n  quotes?: boolean | null\n}\n\nexport type Backticks = boolean | \"all\"\n\n/** The quote characters to use for double and single quotes. */\nexport interface QuoteCharacters {\n  double: string\n  single: string\n}\n\nexport type Dashes = boolean | \"oldschool\" | \"inverted\"\n\nexport type Ellipses = boolean | \"spaced\" | \"unspaced\"\n\n/** `nl.quotes`: check that quotes and apostrophes are straight or smart, as preferred, at each level of nesting; options as retext-quotes takes them. */\nexport interface QuotesOptions {\n  /** The style of quotes and apostrophes to prefer: `smart` by default. */\n  preferred?: QuoteStyle | null\n  /** Smart quotes by nesting level, each one character or an opening and closing pair: `[\"“”\", \"‘’\"]` by default. */\n  smart?: string[] | null\n  /** Straight quotes by nesting level: `[\"\\\"\", \"'\"]` by default. */\n  straight?: string[] | null\n}\n\n/** A style of quotes: straight (`\"`) or smart (`“”`). */\nexport type QuoteStyle = \"smart\" | \"straight\"\n\n/** `nl.contractions`: check apostrophes in contractions, such as `don’t`; options as retext-contractions takes them. */\nexport interface ContractionsOptions {\n  /** Also check contractions written as literals, such as `“hasnt”`. @default false */\n  allowLiterals?: boolean | null\n  /** Expect straight apostrophes (`'`) instead of smart ones (`’`). @default false */\n  straight?: boolean | null\n}\n\n/** The `nl.parse` plugin. */\nexport function parse(options?: ParseOptions): Plugin<\"nl.parse\", ParseOptions> {\n  if (options === undefined) return { name: \"nl.parse\" }\n  return { name: \"nl.parse\", options }\n}\n\n/** The `nl.equality` plugin. */\nexport function equality(options?: EqualityOptions): Plugin<\"nl.equality\", EqualityOptions> {\n  if (options === undefined) return { name: \"nl.equality\" }\n  return { name: \"nl.equality\", options }\n}\n\n/** The `nl.passive` plugin. */\nexport function passive(options?: PassiveOptions): Plugin<\"nl.passive\", PassiveOptions> {\n  if (options === undefined) return { name: \"nl.passive\" }\n  return { name: \"nl.passive\", options }\n}\n\n/** The `nl.readability` plugin. */\nexport function readability(options?: ReadabilityOptions): Plugin<\"nl.readability\", ReadabilityOptions> {\n  if (options === undefined) return { name: \"nl.readability\" }\n  return { name: \"nl.readability\", options }\n}\n\n/** The `nl.repeatedWords` plugin. */\nexport function repeatedWords(): Plugin<\"nl.repeatedWords\"> {\n  return { name: \"nl.repeatedWords\" }\n}\n\n/** The `nl.sentenceSpacing` plugin. */\nexport function sentenceSpacing(options?: SentenceSpacingOptions): Plugin<\"nl.sentenceSpacing\", SentenceSpacingOptions> {\n  if (options === undefined) return { name: \"nl.sentenceSpacing\" }\n  return { name: \"nl.sentenceSpacing\", options }\n}\n\n/** The `nl.stringify` plugin. */\nexport function stringify(): Plugin<\"nl.stringify\"> {\n  return { name: \"nl.stringify\" }\n}\n\n/** The `nl.smartypants` plugin. */\nexport function smartypants(options?: SmartypantsOptions): Plugin<\"nl.smartypants\", SmartypantsOptions> {\n  if (options === undefined) return { name: \"nl.smartypants\" }\n  return { name: \"nl.smartypants\", options }\n}\n\n/** The `nl.quotes` plugin. */\nexport function quotes(options?: QuotesOptions): Plugin<\"nl.quotes\", QuotesOptions> {\n  if (options === undefined) return { name: \"nl.quotes\" }\n  return { name: \"nl.quotes\", options }\n}\n\n/** The `nl.contractions` plugin. */\nexport function contractions(options?: ContractionsOptions): Plugin<\"nl.contractions\", ContractionsOptions> {\n  if (options === undefined) return { name: \"nl.contractions\" }\n  return { name: \"nl.contractions\", options }\n}\n\n/** The `nl.indefiniteArticle` plugin. */\nexport function indefiniteArticle(): Plugin<\"nl.indefiniteArticle\"> {\n  return { name: \"nl.indefiniteArticle\" }\n}\n"]}

package/build/index.d.ts

@@ -0,0 +1,18 @@
+import { Processor } from "./models/processor.ts";
+export type { Compatible, Message, MessageOptions, Node, Place, Point, VFile, } from "./models/file.ts";
+export type { Attacher, Pluggable, PluggableList, Plugin, Preset, Transformer, } from "./models/plugin.ts";
+export type { HostFile, HostMessage } from "./models/vfile.ts";
+export { Processor } from "./models/processor.ts";
+/** A new processor: add plugins with `use`, then `process` text. */
+export declare function textlane(): Processor;
+/** The package version, as the native crate reports it. */
+export declare const version: () => string;
+/** The name of every native plugin, as a pipeline names it. */
+export declare const pluginNames: () => string[];
+/** The most memory, in bytes, each thread keeps after a document to reuse for the next. */
+export declare const retainedMemory: () => number;
+/**
+ * Cap the memory, in bytes, each thread keeps after a document; `0` keeps none. The
+ * default is 256 MB.
+ */
+export declare const setRetainedMemory: (bytes: number) => void;

package/build/index.js

@@ -0,0 +1,27 @@
+import { createRequire } from "node:module";
+import { resolveAddon } from "./actions/addon/resolve.js";
+import { Processor } from "./models/processor.js";
+export { Processor } from "./models/processor.js";
+const require = createRequire(import.meta.url);
+const addon = require(resolveAddon({
+    platform: process.platform,
+    arch: process.arch,
+    env: process.env,
+    resolvePackage: specifier => require.resolve(specifier),
+}));
+/** A new processor: add plugins with `use`, then `process` text. */
+export function textlane() {
+    return new Processor(new addon.Pipeline());
+}
+/** The package version, as the native crate reports it. */
+export const version = addon.version;
+/** The name of every native plugin, as a pipeline names it. */
+export const pluginNames = addon.pluginNames;
+/** The most memory, in bytes, each thread keeps after a document to reuse for the next. */
+export const retainedMemory = addon.retainedMemory;
+/**
+ * Cap the memory, in bytes, each thread keeps after a document; `0` keeps none. The
+ * default is 256 MB.
+ */
+export const setRetainedMemory = addon.setRetainedMemory;
+//# sourceMappingURL=data:application/json;base64,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

package/build/models/addon.d.ts

@@ -0,0 +1,35 @@
+import type { Message, Node, VFile } from "./file.ts";
+/** The crate's pipeline as the addon exposes it: values cross as JSON. */
+export interface NativePipeline {
+    use(value: unknown, options?: unknown): void;
+    data(key?: string): unknown;
+    setData(key: string, value: unknown): void;
+    replaceData(data: Record<string, unknown>): void;
+    freeze(): void;
+    parse(text: string): Node;
+    run(tree: Node, value?: string): Node;
+    runSync(tree: Node, value?: string): Node;
+    stringify(tree: Node): string;
+    process(text: string, path?: string): VFile;
+    processSync(text: string, path?: string): VFile;
+    hosts(): number[];
+    startRun(tree: Node, value: string | undefined, sync: boolean): NativeRun<Node>;
+    startProcess(text: string, sync: boolean, path?: string): NativeRun<VFile>;
+}
+/** A run paused before host plugins until `resume`, then finished with `result`. */
+export interface NativeRun<Result> {
+    hosts(): number[];
+    tree(): Node;
+    value(): string | null;
+    messages(): Message[];
+    resume(tree: Node, messages: Message[]): void;
+    result(): Result;
+}
+/** What the napi addon exports. */
+export interface Addon {
+    version(): string;
+    pluginNames(): string[];
+    retainedMemory(): number;
+    setRetainedMemory(bytes: number): void;
+    Pipeline: new () => NativePipeline;
+}

package/build/models/addon.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRkb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9tb2RlbHMvYWRkb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTWVzc2FnZSwgTm9kZSwgVkZpbGUgfSBmcm9tIFwiLi9maWxlLnRzXCJcblxuLyoqIFRoZSBjcmF0ZSdzIHBpcGVsaW5lIGFzIHRoZSBhZGRvbiBleHBvc2VzIGl0OiB2YWx1ZXMgY3Jvc3MgYXMgSlNPTi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTmF0aXZlUGlwZWxpbmUge1xuICB1c2UodmFsdWU6IHVua25vd24sIG9wdGlvbnM/OiB1bmtub3duKTogdm9pZFxuICBkYXRhKGtleT86IHN0cmluZyk6IHVua25vd25cbiAgc2V0RGF0YShrZXk6IHN0cmluZywgdmFsdWU6IHVua25vd24pOiB2b2lkXG4gIHJlcGxhY2VEYXRhKGRhdGE6IFJlY29yZDxzdHJpbmcsIHVua25vd24+KTogdm9pZFxuICBmcmVlemUoKTogdm9pZFxuICBwYXJzZSh0ZXh0OiBzdHJpbmcpOiBOb2RlXG4gIHJ1bih0cmVlOiBOb2RlLCB2YWx1ZT86IHN0cmluZyk6IE5vZGVcbiAgcnVuU3luYyh0cmVlOiBOb2RlLCB2YWx1ZT86IHN0cmluZyk6IE5vZGVcbiAgc3RyaW5naWZ5KHRyZWU6IE5vZGUpOiBzdHJpbmdcbiAgcHJvY2Vzcyh0ZXh0OiBzdHJpbmcsIHBhdGg/OiBzdHJpbmcpOiBWRmlsZVxuICBwcm9jZXNzU3luYyh0ZXh0OiBzdHJpbmcsIHBhdGg/OiBzdHJpbmcpOiBWRmlsZVxuICBob3N0cygpOiBudW1iZXJbXVxuICBzdGFydFJ1bih0cmVlOiBOb2RlLCB2YWx1ZTogc3RyaW5nIHwgdW5kZWZpbmVkLCBzeW5jOiBib29sZWFuKTogTmF0aXZlUnVuPE5vZGU+XG4gIHN0YXJ0UHJvY2Vzcyh0ZXh0OiBzdHJpbmcsIHN5bmM6IGJvb2xlYW4sIHBhdGg/OiBzdHJpbmcpOiBOYXRpdmVSdW48VkZpbGU+XG59XG5cbi8qKiBBIHJ1biBwYXVzZWQgYmVmb3JlIGhvc3QgcGx1Z2lucyB1bnRpbCBgcmVzdW1lYCwgdGhlbiBmaW5pc2hlZCB3aXRoIGByZXN1bHRgLiAqL1xuZXhwb3J0IGludGVyZmFjZSBOYXRpdmVSdW48UmVzdWx0PiB7XG4gIGhvc3RzKCk6IG51bWJlcltdXG4gIHRyZWUoKTogTm9kZVxuICB2YWx1ZSgpOiBzdHJpbmcgfCBudWxsXG4gIG1lc3NhZ2VzKCk6IE1lc3NhZ2VbXVxuICByZXN1bWUodHJlZTogTm9kZSwgbWVzc2FnZXM6IE1lc3NhZ2VbXSk6IHZvaWRcbiAgcmVzdWx0KCk6IFJlc3VsdFxufVxuXG4vKiogV2hhdCB0aGUgbmFwaSBhZGRvbiBleHBvcnRzLiAqL1xuZXhwb3J0IGludGVyZmFjZSBBZGRvbiB7XG4gIHZlcnNpb24oKTogc3RyaW5nXG4gIHBsdWdpbk5hbWVzKCk6IHN0cmluZ1tdXG4gIHJldGFpbmVkTWVtb3J5KCk6IG51bWJlclxuICBzZXRSZXRhaW5lZE1lbW9yeShieXRlczogbnVtYmVyKTogdm9pZFxuICBQaXBlbGluZTogbmV3ICgpID0+IE5hdGl2ZVBpcGVsaW5lXG59XG4iXX0=

package/build/models/file.d.ts

@@ -0,0 +1,52 @@
+/** A unist node as JSON: what `parse` returns and `run` and `stringify` take. */
+export interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/** One place in a file: a 1-indexed line and column and a 0-indexed offset, when known. */
+export interface Point {
+    line: number;
+    column: number;
+    offset: number | null;
+}
+/** A diagnostic a plugin reported, as vfile-message has it. */
+export interface Message {
+    reason: string;
+    ruleId: string | null;
+    source: string | null;
+    place: {
+        start: Point;
+        end: Point;
+    } | null;
+}
+/** What `process` gives back, as a vfile: the output, the messages and the file's data. */
+export interface VFile {
+    value: string;
+    messages: Message[];
+    data: Record<string, unknown>;
+    path?: string;
+}
+/** A document: its text, or a file holding it as `value`, with its path when known. */
+export type Compatible = string | {
+    value: string;
+    path?: string;
+};
+/** Where a message is: a point, a position, or a node holding one. */
+export type Place = {
+    line: number;
+    column: number;
+    offset?: number | null;
+} | {
+    start: Point;
+    end: Point;
+} | {
+    position?: unknown;
+};
+/** What `message` takes besides the reason, as vfile-message names it. */
+export interface MessageOptions {
+    ancestors?: unknown[];
+    cause?: unknown;
+    place?: Place;
+    ruleId?: string;
+    source?: string;
+}

package/build/models/file.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21vZGVscy9maWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQSB1bmlzdCBub2RlIGFzIEpTT046IHdoYXQgYHBhcnNlYCByZXR1cm5zIGFuZCBgcnVuYCBhbmQgYHN0cmluZ2lmeWAgdGFrZS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTm9kZSB7XG4gIHR5cGU6IHN0cmluZ1xuICBba2V5OiBzdHJpbmddOiB1bmtub3duXG59XG5cbi8qKiBPbmUgcGxhY2UgaW4gYSBmaWxlOiBhIDEtaW5kZXhlZCBsaW5lIGFuZCBjb2x1bW4gYW5kIGEgMC1pbmRleGVkIG9mZnNldCwgd2hlbiBrbm93bi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUG9pbnQge1xuICBsaW5lOiBudW1iZXJcbiAgY29sdW1uOiBudW1iZXJcbiAgb2Zmc2V0OiBudW1iZXIgfCBudWxsXG59XG5cbi8qKiBBIGRpYWdub3N0aWMgYSBwbHVnaW4gcmVwb3J0ZWQsIGFzIHZmaWxlLW1lc3NhZ2UgaGFzIGl0LiAqL1xuZXhwb3J0IGludGVyZmFjZSBNZXNzYWdlIHtcbiAgcmVhc29uOiBzdHJpbmdcbiAgcnVsZUlkOiBzdHJpbmcgfCBudWxsXG4gIHNvdXJjZTogc3RyaW5nIHwgbnVsbFxuICBwbGFjZTogeyBzdGFydDogUG9pbnQ7IGVuZDogUG9pbnQgfSB8IG51bGxcbn1cblxuLyoqIFdoYXQgYHByb2Nlc3NgIGdpdmVzIGJhY2ssIGFzIGEgdmZpbGU6IHRoZSBvdXRwdXQsIHRoZSBtZXNzYWdlcyBhbmQgdGhlIGZpbGUncyBkYXRhLiAqL1xuZXhwb3J0IGludGVyZmFjZSBWRmlsZSB7XG4gIHZhbHVlOiBzdHJpbmdcbiAgbWVzc2FnZXM6IE1lc3NhZ2VbXVxuICBkYXRhOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxuICBwYXRoPzogc3RyaW5nXG59XG5cbi8qKiBBIGRvY3VtZW50OiBpdHMgdGV4dCwgb3IgYSBmaWxlIGhvbGRpbmcgaXQgYXMgYHZhbHVlYCwgd2l0aCBpdHMgcGF0aCB3aGVuIGtub3duLiAqL1xuZXhwb3J0IHR5cGUgQ29tcGF0aWJsZSA9IHN0cmluZyB8IHsgdmFsdWU6IHN0cmluZzsgcGF0aD86IHN0cmluZyB9XG5cbi8qKiBXaGVyZSBhIG1lc3NhZ2UgaXM6IGEgcG9pbnQsIGEgcG9zaXRpb24sIG9yIGEgbm9kZSBob2xkaW5nIG9uZS4gKi9cbmV4cG9ydCB0eXBlIFBsYWNlID1cbiAgfCB7IGxpbmU6IG51bWJlcjsgY29sdW1uOiBudW1iZXI7IG9mZnNldD86IG51bWJlciB8IG51bGwgfVxuICB8IHsgc3RhcnQ6IFBvaW50OyBlbmQ6IFBvaW50IH1cbiAgfCB7IHBvc2l0aW9uPzogdW5rbm93biB9XG5cbi8qKiBXaGF0IGBtZXNzYWdlYCB0YWtlcyBiZXNpZGVzIHRoZSByZWFzb24sIGFzIHZmaWxlLW1lc3NhZ2UgbmFtZXMgaXQuICovXG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VPcHRpb25zIHtcbiAgYW5jZXN0b3JzPzogdW5rbm93bltdXG4gIGNhdXNlPzogdW5rbm93blxuICBwbGFjZT86IFBsYWNlXG4gIHJ1bGVJZD86IHN0cmluZ1xuICBzb3VyY2U/OiBzdHJpbmdcbn1cbiJdfQ==

package/build/models/host.d.ts

@@ -0,0 +1,7 @@
+import type { Attacher, Transformer } from "./plugin.ts";
+/** A JavaScript plugin a processor uses: its attacher, options and, once attached, its transformer. */
+export interface Host {
+    attacher: Attacher;
+    parameters: unknown[];
+    transformer?: Transformer;
+}

package/build/models/host.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL21vZGVscy9ob3N0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEF0dGFjaGVyLCBUcmFuc2Zvcm1lciB9IGZyb20gXCIuL3BsdWdpbi50c1wiXG5cbi8qKiBBIEphdmFTY3JpcHQgcGx1Z2luIGEgcHJvY2Vzc29yIHVzZXM6IGl0cyBhdHRhY2hlciwgb3B0aW9ucyBhbmQsIG9uY2UgYXR0YWNoZWQsIGl0cyB0cmFuc2Zvcm1lci4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSG9zdCB7XG4gIGF0dGFjaGVyOiBBdHRhY2hlclxuICBwYXJhbWV0ZXJzOiB1bmtub3duW11cbiAgdHJhbnNmb3JtZXI/OiBUcmFuc2Zvcm1lclxufVxuIl19

package/build/models/plugin.d.ts

@@ -0,0 +1,26 @@
+import type { Node } from "./file.ts";
+import type { HostFile } from "./vfile.ts";
+/** A native plugin as a pipeline names it, with its options when given. */
+export interface Plugin<Name extends string = string, Options = unknown> {
+    name: Name;
+    options?: Options;
+}
+/** Plugins and the settings they share, as unified's presets. */
+export interface Preset {
+    plugins?: PluggableList;
+    settings?: Record<string, unknown>;
+}
+/**
+ * A JavaScript plugin, as unified's attachers: called with the processor as `this` and its
+ * options when the processor freezes, it returns the transformer the pipeline runs.
+ */
+export type Attacher = (this: never, ...parameters: never[]) => unknown;
+/**
+ * What an attacher returns: it changes the tree in place or returns a new one, directly,
+ * through a promise or through `next`.
+ */
+export type Transformer = (tree: Node, file: HostFile, next: (error?: unknown, tree?: Node) => void) => unknown;
+/** A plugin, by descriptor, name or attacher, with options, or a preset. */
+export type Pluggable = Plugin | string | Attacher | [Plugin | string | Attacher, unknown?] | Preset;
+/** Several pluggables, used in order. */
+export type PluggableList = Pluggable[];

package/build/models/plugin.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vbW9kZWxzL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOb2RlIH0gZnJvbSBcIi4vZmlsZS50c1wiXG5pbXBvcnQgdHlwZSB7IEhvc3RGaWxlIH0gZnJvbSBcIi4vdmZpbGUudHNcIlxuXG4vKiogQSBuYXRpdmUgcGx1Z2luIGFzIGEgcGlwZWxpbmUgbmFtZXMgaXQsIHdpdGggaXRzIG9wdGlvbnMgd2hlbiBnaXZlbi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGx1Z2luPE5hbWUgZXh0ZW5kcyBzdHJpbmcgPSBzdHJpbmcsIE9wdGlvbnMgPSB1bmtub3duPiB7XG4gIG5hbWU6IE5hbWVcbiAgb3B0aW9ucz86IE9wdGlvbnNcbn1cblxuLyoqIFBsdWdpbnMgYW5kIHRoZSBzZXR0aW5ncyB0aGV5IHNoYXJlLCBhcyB1bmlmaWVkJ3MgcHJlc2V0cy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUHJlc2V0IHtcbiAgcGx1Z2lucz86IFBsdWdnYWJsZUxpc3RcbiAgc2V0dGluZ3M/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPlxufVxuXG4vKipcbiAqIEEgSmF2YVNjcmlwdCBwbHVnaW4sIGFzIHVuaWZpZWQncyBhdHRhY2hlcnM6IGNhbGxlZCB3aXRoIHRoZSBwcm9jZXNzb3IgYXMgYHRoaXNgIGFuZCBpdHNcbiAqIG9wdGlvbnMgd2hlbiB0aGUgcHJvY2Vzc29yIGZyZWV6ZXMsIGl0IHJldHVybnMgdGhlIHRyYW5zZm9ybWVyIHRoZSBwaXBlbGluZSBydW5zLlxuICovXG5leHBvcnQgdHlwZSBBdHRhY2hlciA9ICh0aGlzOiBuZXZlciwgLi4ucGFyYW1ldGVyczogbmV2ZXJbXSkgPT4gdW5rbm93blxuXG4vKipcbiAqIFdoYXQgYW4gYXR0YWNoZXIgcmV0dXJuczogaXQgY2hhbmdlcyB0aGUgdHJlZSBpbiBwbGFjZSBvciByZXR1cm5zIGEgbmV3IG9uZSwgZGlyZWN0bHksXG4gKiB0aHJvdWdoIGEgcHJvbWlzZSBvciB0aHJvdWdoIGBuZXh0YC5cbiAqL1xuZXhwb3J0IHR5cGUgVHJhbnNmb3JtZXIgPSAoXG4gIHRyZWU6IE5vZGUsXG4gIGZpbGU6IEhvc3RGaWxlLFxuICBuZXh0OiAoZXJyb3I/OiB1bmtub3duLCB0cmVlPzogTm9kZSkgPT4gdm9pZCxcbikgPT4gdW5rbm93blxuXG4vKiogQSBwbHVnaW4sIGJ5IGRlc2NyaXB0b3IsIG5hbWUgb3IgYXR0YWNoZXIsIHdpdGggb3B0aW9ucywgb3IgYSBwcmVzZXQuICovXG5leHBvcnQgdHlwZSBQbHVnZ2FibGUgPVxuICB8IFBsdWdpblxuICB8IHN0cmluZ1xuICB8IEF0dGFjaGVyXG4gIHwgW1BsdWdpbiB8IHN0cmluZyB8IEF0dGFjaGVyLCB1bmtub3duP11cbiAgfCBQcmVzZXRcblxuLyoqIFNldmVyYWwgcGx1Z2dhYmxlcywgdXNlZCBpbiBvcmRlci4gKi9cbmV4cG9ydCB0eXBlIFBsdWdnYWJsZUxpc3QgPSBQbHVnZ2FibGVbXVxuIl19

package/build/models/processor.d.ts

@@ -0,0 +1,39 @@
+import type { NativePipeline } from "./addon.ts";
+import type { Compatible, Node, VFile } from "./file.ts";
+import type { Pluggable, PluggableList, Preset } from "./plugin.ts";
+/**
+ * unified's processor over the native pipeline; every call is the crate's, except that
+ * JavaScript plugins run here when a run pauses before them.
+ */
+export declare class Processor {
+    #private;
+    constructor(native: NativePipeline);
+    /**
+     * Add a plugin, a list of them or a preset; a plugin used again is reconfigured. A
+     * JavaScript plugin is an attacher, called with the processor and its options at freeze.
+     */
+    use(value: Pluggable | PluggableList | Preset | null | undefined, ...options: unknown[]): this;
+    /** All data, or the value under `key`. */
+    data(): Record<string, unknown>;
+    data(key: string): unknown;
+    /** Set the value under `key`, or replace all data. */
+    data(key: string, value: unknown): this;
+    data(dataset: Record<string, unknown>): this;
+    /** Attach every plugin; later `use` and `data` setters fail. */
+    freeze(): this;
+    /** Parse a document into a tree. */
+    parse(document: Compatible): Node;
+    /**
+     * Run the transforms, finishing asynchronous stages; `file`, the text `tree` was parsed
+     * from, lets bridges read it and keeps positions in the result.
+     */
+    run(tree: Node, file?: Compatible): Promise<Node>;
+    /** Run the transforms; fails with `async-in-sync` on an asynchronous stage. */
+    runSync(tree: Node, file?: Compatible): Node;
+    /** Compile a tree, running no transform. */
+    stringify(tree: Node): string;
+    /** Parse, run and compile a document, finishing asynchronous stages. */
+    process(document: Compatible): Promise<VFile>;
+    /** Parse, run and compile a document; fails with `async-in-sync` on an asynchronous stage. */
+    processSync(document: Compatible): VFile;
+}

package/build/models/processor.js

@@ -0,0 +1,154 @@
+import { isAttacher } from "../actions/attacher/check.js";
+import { isPlainObject, mergeOptions } from "../actions/options/merge.js";
+import { mapPluggable } from "../actions/pluggable/map.js";
+import { finishRun } from "../actions/run/finish.js";
+import { isTransformer } from "../actions/transformer/check.js";
+import { HostFile } from "./vfile.js";
+/**
+ * unified's processor over the native pipeline; every call is the crate's, except that
+ * JavaScript plugins run here when a run pauses before them.
+ */
+export class Processor {
+    #native;
+    #ids = new Map();
+    #hosts = new Map();
+    #attached = false;
+    constructor(native) {
+        this.#native = native;
+    }
+    /**
+     * Add a plugin, a list of them or a preset; a plugin used again is reconfigured. A
+     * JavaScript plugin is an attacher, called with the processor and its options at freeze.
+     */
+    use(value, ...options) {
+        if (isAttacher(value)) {
+            this.#native.use([this.#register(value, options)]);
+            return this;
+        }
+        const register = (attacher, parameters) => this.#register(attacher, parameters);
+        this.#native.use(mapPluggable(value ?? null, register), options[0]);
+        return this;
+    }
+    data(key, ...value) {
+        if (typeof key === "object") {
+            this.#native.replaceData(key);
+            return this;
+        }
+        if (key !== undefined && value.length > 0) {
+            this.#native.setData(key, value[0]);
+            return this;
+        }
+        return this.#native.data(key);
+    }
+    /** Attach every plugin; later `use` and `data` setters fail. */
+    freeze() {
+        this.#attach();
+        this.#native.freeze();
+        return this;
+    }
+    /** Parse a document into a tree. */
+    parse(document) {
+        this.#attach();
+        return this.#native.parse(readValue(document) ?? "");
+    }
+    /**
+     * Run the transforms, finishing asynchronous stages; `file`, the text `tree` was parsed
+     * from, lets bridges read it and keeps positions in the result.
+     */
+    async run(tree, file) {
+        const value = readValue(file);
+        if (!this.#attach())
+            return this.#native.run(tree, value);
+        const run = this.#native.startRun(tree, value, false);
+        const host = new HostFile({ value, path: readPath(file) });
+        await finishRun({ run, hosts: this.#hosts, file: host, sync: false, call: "run" });
+        return run.result();
+    }
+    /** Run the transforms; fails with `async-in-sync` on an asynchronous stage. */
+    runSync(tree, file) {
+        const value = readValue(file);
+        if (!this.#attach())
+            return this.#native.runSync(tree, value);
+        const run = this.#native.startRun(tree, value, true);
+        const host = new HostFile({ value, path: readPath(file) });
+        void finishRun({ run, hosts: this.#hosts, file: host, sync: true, call: "run" });
+        return run.result();
+    }
+    /** Compile a tree, running no transform. */
+    stringify(tree) {
+        this.#attach();
+        return this.#native.stringify(tree);
+    }
+    /** Parse, run and compile a document, finishing asynchronous stages. */
+    async process(document) {
+        const text = readValue(document) ?? "";
+        if (!this.#attach())
+            return withPath(this.#native.process(text, readPath(document)), document);
+        const run = this.#native.startProcess(text, false, readPath(document));
+        const file = new HostFile({ value: run.value() ?? text, path: readPath(document) });
+        await finishRun({ run, hosts: this.#hosts, file, sync: false, call: "process" });
+        return withPath(mergeData(run.result(), file.data), document);
+    }
+    /** Parse, run and compile a document; fails with `async-in-sync` on an asynchronous stage. */
+    processSync(document) {
+        const text = readValue(document) ?? "";
+        if (!this.#attach())
+            return withPath(this.#native.processSync(text, readPath(document)), document);
+        const run = this.#native.startProcess(text, true, readPath(document));
+        const file = new HostFile({ value: run.value() ?? text, path: readPath(document) });
+        void finishRun({ run, hosts: this.#hosts, file, sync: true, call: "process" });
+        return withPath(mergeData(run.result(), file.data), document);
+    }
+    // unified's addPlugin: the same attacher is one plugin, its object options merged
+    #register(attacher, parameters) {
+        let id = this.#ids.get(attacher);
+        if (id === undefined) {
+            id = this.#ids.size;
+            this.#ids.set(attacher, id);
+            this.#hosts.set(id, { attacher, parameters });
+            return [{ host: id }, parameters[0] !== false];
+        }
+        const host = this.#hosts.get(id);
+        if (!host || parameters.length === 0)
+            return [{ host: id }];
+        const [primary, ...rest] = parameters;
+        const merged = isPlainObject(host.parameters[0]) && isPlainObject(primary)
+            ? mergeOptions(host.parameters[0], primary)
+            : primary;
+        host.parameters = [merged, ...rest];
+        return [{ host: id }, merged !== false];
+    }
+    // Attachers run once, before the native pipeline freezes, so they can still set data;
+    // whether any JavaScript plugin is on decides if runs pause for them
+    #attach() {
+        if (!this.#attached) {
+            this.#attached = true;
+            for (const id of this.#native.hosts()) {
+                const host = this.#hosts.get(id);
+                if (!host)
+                    continue;
+                const [primary, ...rest] = host.parameters;
+                const parameters = primary === true ? [undefined, ...rest] : host.parameters;
+                const transformer = Reflect.apply(host.attacher, this, parameters);
+                if (isTransformer(transformer))
+                    host.transformer = transformer;
+            }
+        }
+        return this.#native.hosts().length > 0;
+    }
+}
+function readValue(file) {
+    return typeof file === "string" ? file : file?.value;
+}
+function readPath(file) {
+    return typeof file === "string" ? undefined : file?.path;
+}
+// Native stages' data first, then what JavaScript plugins stored over it
+function mergeData(result, data) {
+    return { ...result, data: { ...result.data, ...data } };
+}
+function withPath(file, document) {
+    const path = readPath(document);
+    return path === undefined ? file : { ...file, path };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processor.js","sourceRoot":"","sources":["../../models/processor.ts"],"names":[],"mappings":"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","sourcesContent":["import { isAttacher } from \"../actions/attacher/check.ts\"\nimport { isPlainObject, mergeOptions } from \"../actions/options/merge.ts\"\nimport { type HostEntry, mapPluggable } from \"../actions/pluggable/map.ts\"\nimport { finishRun } from \"../actions/run/finish.ts\"\nimport { isTransformer } from \"../actions/transformer/check.ts\"\nimport type { NativePipeline } from \"./addon.ts\"\nimport type { Compatible, Node, VFile } from \"./file.ts\"\nimport type { Host } from \"./host.ts\"\nimport type { Attacher, Pluggable, PluggableList, Preset } from \"./plugin.ts\"\nimport { HostFile } from \"./vfile.ts\"\n\n/**\n * unified's processor over the native pipeline; every call is the crate's, except that\n * JavaScript plugins run here when a run pauses before them.\n */\nexport class Processor {\n  #native: NativePipeline\n  #ids = new Map<Attacher, number>()\n  #hosts = new Map<number, Host>()\n  #attached = false\n\n  constructor(native: NativePipeline) {\n    this.#native = native\n  }\n\n  /**\n   * Add a plugin, a list of them or a preset; a plugin used again is reconfigured. A\n   * JavaScript plugin is an attacher, called with the processor and its options at freeze.\n   */\n  use(\n    value: Pluggable | PluggableList | Preset | null | undefined,\n    ...options: unknown[]\n  ) {\n    if (isAttacher(value)) {\n      this.#native.use([this.#register(value, options)])\n      return this\n    }\n    const register = (attacher: Attacher, parameters: unknown[]) =>\n      this.#register(attacher, parameters)\n    this.#native.use(mapPluggable(value ?? null, register), options[0])\n    return this\n  }\n\n  /** All data, or the value under `key`. */\n  data(): Record<string, unknown>\n  data(key: string): unknown\n  /** Set the value under `key`, or replace all data. */\n  data(key: string, value: unknown): this\n  data(dataset: Record<string, unknown>): this\n  data(key?: string | Record<string, unknown>, ...value: unknown[]) {\n    if (typeof key === \"object\") {\n      this.#native.replaceData(key)\n      return this\n    }\n    if (key !== undefined && value.length > 0) {\n      this.#native.setData(key, value[0])\n      return this\n    }\n    return this.#native.data(key)\n  }\n\n  /** Attach every plugin; later `use` and `data` setters fail. */\n  freeze() {\n    this.#attach()\n    this.#native.freeze()\n    return this\n  }\n\n  /** Parse a document into a tree. */\n  parse(document: Compatible) {\n    this.#attach()\n    return this.#native.parse(readValue(document) ?? \"\")\n  }\n\n  /**\n   * Run the transforms, finishing asynchronous stages; `file`, the text `tree` was parsed\n   * from, lets bridges read it and keeps positions in the result.\n   */\n  async run(tree: Node, file?: Compatible) {\n    const value = readValue(file)\n    if (!this.#attach()) return this.#native.run(tree, value)\n    const run = this.#native.startRun(tree, value, false)\n    const host = new HostFile({ value, path: readPath(file) })\n    await finishRun({ run, hosts: this.#hosts, file: host, sync: false, call: \"run\" })\n    return run.result()\n  }\n\n  /** Run the transforms; fails with `async-in-sync` on an asynchronous stage. */\n  runSync(tree: Node, file?: Compatible) {\n    const value = readValue(file)\n    if (!this.#attach()) return this.#native.runSync(tree, value)\n    const run = this.#native.startRun(tree, value, true)\n    const host = new HostFile({ value, path: readPath(file) })\n    void finishRun({ run, hosts: this.#hosts, file: host, sync: true, call: \"run\" })\n    return run.result()\n  }\n\n  /** Compile a tree, running no transform. */\n  stringify(tree: Node) {\n    this.#attach()\n    return this.#native.stringify(tree)\n  }\n\n  /** Parse, run and compile a document, finishing asynchronous stages. */\n  async process(document: Compatible): Promise<VFile> {\n    const text = readValue(document) ?? \"\"\n    if (!this.#attach())\n      return withPath(this.#native.process(text, readPath(document)), document)\n    const run = this.#native.startProcess(text, false, readPath(document))\n    const file = new HostFile({ value: run.value() ?? text, path: readPath(document) })\n    await finishRun({ run, hosts: this.#hosts, file, sync: false, call: \"process\" })\n    return withPath(mergeData(run.result(), file.data), document)\n  }\n\n  /** Parse, run and compile a document; fails with `async-in-sync` on an asynchronous stage. */\n  processSync(document: Compatible): VFile {\n    const text = readValue(document) ?? \"\"\n    if (!this.#attach())\n      return withPath(this.#native.processSync(text, readPath(document)), document)\n    const run = this.#native.startProcess(text, true, readPath(document))\n    const file = new HostFile({ value: run.value() ?? text, path: readPath(document) })\n    void finishRun({ run, hosts: this.#hosts, file, sync: true, call: \"process\" })\n    return withPath(mergeData(run.result(), file.data), document)\n  }\n\n  // unified's addPlugin: the same attacher is one plugin, its object options merged\n  #register(attacher: Attacher, parameters: unknown[]): HostEntry {\n    let id = this.#ids.get(attacher)\n    if (id === undefined) {\n      id = this.#ids.size\n      this.#ids.set(attacher, id)\n      this.#hosts.set(id, { attacher, parameters })\n      return [{ host: id }, parameters[0] !== false]\n    }\n    const host = this.#hosts.get(id)\n    if (!host || parameters.length === 0) return [{ host: id }]\n    const [primary, ...rest] = parameters\n    const merged =\n      isPlainObject(host.parameters[0]) && isPlainObject(primary)\n        ? mergeOptions(host.parameters[0], primary)\n        : primary\n    host.parameters = [merged, ...rest]\n    return [{ host: id }, merged !== false]\n  }\n\n  // Attachers run once, before the native pipeline freezes, so they can still set data;\n  // whether any JavaScript plugin is on decides if runs pause for them\n  #attach() {\n    if (!this.#attached) {\n      this.#attached = true\n      for (const id of this.#native.hosts()) {\n        const host = this.#hosts.get(id)\n        if (!host) continue\n        const [primary, ...rest] = host.parameters\n        const parameters = primary === true ? [undefined, ...rest] : host.parameters\n        const transformer: unknown = Reflect.apply(host.attacher, this, parameters)\n        if (isTransformer(transformer)) host.transformer = transformer\n      }\n    }\n    return this.#native.hosts().length > 0\n  }\n}\n\nfunction readValue(file: Compatible | undefined) {\n  return typeof file === \"string\" ? file : file?.value\n}\n\nfunction readPath(file: Compatible | undefined) {\n  return typeof file === \"string\" ? undefined : file?.path\n}\n\n// Native stages' data first, then what JavaScript plugins stored over it\nfunction mergeData(result: VFile, data: Record<string, unknown>): VFile {\n  return { ...result, data: { ...result.data, ...data } }\n}\n\nfunction withPath(file: VFile, document: Compatible) {\n  const path = readPath(document)\n  return path === undefined ? file : { ...file, path }\n}\n"]}