svelte-origin 0.0.0 → 1.0.0-next.49

package/dist/runtime/types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Core types for svelte-origin runtime
+ *
+ * This file defines the type system for origins.
+ *
+ * Key concepts:
+ * - Origins are defined with $origin({...}) macro using `this` context
+ * - The macro transforms to a factory with __attrSchema and __create
+ * - __create receives a reactive attrs object and returns an instance
+ */
+/**
+ * Marker type for bindable attrs.
+ * Used inside $origin({ props: $origin.props({ count: $bindable(0) }) })
+ *
+ * At macro expansion time, $bindable is replaced with __bindable()
+ * to mark attrs that should become $bindable() in the component.
+ */
+export interface Bindable<T = unknown> {
+    readonly __bindable: true;
+    readonly default: T;
+}
+/**
+ * Schema describing a single attr's metadata.
+ * Extracted at transformation time from the attrs definition.
+ */
+export interface AttrSchemaEntry {
+    /** The default value (undefined if no default) */
+    default: unknown;
+    /** Whether this attr is bindable (two-way binding) */
+    bindable: boolean;
+    /** Whether this attr has a default value */
+    hasDefault: boolean;
+}
+/**
+ * Full attr schema for an origin.
+ * Maps attr name -> schema entry.
+ */
+export interface AttrSchema {
+    [key: string]: AttrSchemaEntry;
+}
+/**
+ * The reactive attrs object passed to the origin factory's __create function.
+ * This is created by the component with getters/setters that link to the
+ * actual $props() destructured variables.
+ *
+ * @example
+ * // In component after transformation:
+ * let { label = 'Counter', count = $bindable(0) } = $props()
+ * let __reactiveAttrs = {
+ *   get label() { return label },
+ *   get count() { return count },
+ *   set count(v) { count = v }
+ * }
+ * let counter = Counter.__create(__reactiveAttrs)
+ */
+export type ReactiveAttrs<T> = T extends Record<string, any> ? {
+    [K in keyof T]: UnwrapBindable<T[K]>;
+} : Record<string, never>;
+/**
+ * Unwrap Bindable<T> to T, pass through other types
+ */
+export type UnwrapBindable<T> = T extends Bindable<infer U> ? U : T;
+/**
+ * The factory object created by the $origin macro transformation.
+ *
+ * Contains:
+ * - __origin: marker for identification
+ * - __attrSchema: metadata about attrs (defaults, bindable markers)
+ * - __parents: parent origin factories for inheritance
+ * - __create: function that receives reactive attrs and returns instance
+ * - __onInit: optional callback that runs after instance creation, can receive extra args
+ *
+ * The factory is also callable for convenience: `Counter(attrs)` calls `Counter.__create(attrs)`
+ * Factory supports: `Counter(attrs?, ...initArgs?)` where initArgs are passed to __onInit
+ */
+export interface OriginFactory<TInstance = unknown, TAttrs = Record<string, any>> {
+    /** Create an instance with the given reactive attrs and optional init args */
+    (attrs?: TAttrs | null, ...initArgs: any[]): TInstance & OriginInstanceExtras;
+    /** Marker to identify origin factories */
+    readonly __origin: true;
+    /** The attr schema extracted from the definition */
+    readonly __attrSchema: AttrSchema;
+    /** Parent origin factories (for inheritance) */
+    readonly __parents: OriginFactory<any, any>[];
+    /** The actual factory function that creates instances */
+    readonly __create: (attrs: TAttrs, superInstances?: any[]) => TInstance;
+    /** Optional initialization callback that runs after instance creation, receives any extra args passed to factory */
+    readonly __onInit?: (this: TInstance, ...args: any[]) => void | (() => void);
+}
+/**
+ * Standalone attrs schema factory created by $origin.props({...}) outside of $origin.
+ * Can be used to define reusable attr schemas.
+ *
+ * @example
+ * // Define reusable attrs
+ * export const BaseAttrs = $origin.props({
+ *   label: 'Default',
+ *   disabled: false
+ * })
+ *
+ * // Extend in origin
+ * export const Widget = $origin({
+ *   props: $origin.props([BaseAttrs], {
+ *     value: $bindable(0)
+ *   })
+ * })
+ */
+export interface AttrsFactory<_TAttrs = Record<string, any>> {
+    /** Marker to identify attrs factories */
+    readonly __attrs: true;
+    /** The attr schema */
+    readonly __attrSchema: AttrSchema;
+    /** Parent attr factories (for inheritance) */
+    readonly __parents: AttrsFactory<any>[];
+}
+/**
+ * Attachment registry returned by $attachments getter.
+ * Maps Symbol keys to attachment functions.
+ */
+export type AttachmentRegistry = Record<symbol, (element: Element) => void | (() => void)>;
+/**
+ * Properties added to all origin instances at runtime.
+ * These are injected by __createOrigin after __create returns.
+ */
+export interface OriginInstanceExtras {
+    /**
+     * Getter that returns attachment functions that can be spread onto elements.
+     * Returns an object with Symbol keys mapping to attachment functions.
+     *
+     * @example
+     * <div {...instance.$attachments}>
+     */
+    readonly $attachments: AttachmentRegistry;
+}
+/**
+ * The origin instance has:
+ * - attrs: reactive attrs object (passed in)
+ * - super: parent instance (if extending)
+ * - $attachments: attachment registry (injected by runtime)
+ * - All other members from the definition (state, getters, methods)
+ */
+export interface OriginInstance<TAttrs = Record<string, any>> extends OriginInstanceExtras {
+    /** Reactive attrs object */
+    readonly attrs: TAttrs;
+    /** Parent instance (if extending) */
+    readonly super?: any;
+    /** Additional members from definition */
+    [key: string]: any;
+}
+/**
+ * Extract the component attrs type from an origin's attr schema.
+ * This is what the component will accept as attrs.
+ */
+export type ComponentAttrs<T extends OriginFactory<any, any>> = T extends OriginFactory<any, infer A> ? Partial<A> : Record<string, any>;
+/**
+ * Extract the instance type from an origin factory
+ */
+export type InstanceOf<T extends OriginFactory<any, any>> = T extends OriginFactory<infer I, any> ? I : never;
+/**
+ * Merge parent origins with child definition.
+ * The child's attrs are merged with parent attrs.
+ * The child gets access to `this.super` for parent methods.
+ */
+export type MergedOrigin<Parents extends OriginFactory<any, any>[], TInstance> = TInstance & {
+    super: Parents extends [OriginFactory<infer P, any>] ? P : Parents extends [OriginFactory<infer P1, any>, ...infer _Rest] ? P1 : never;
+};
+/**
+ * Attrs for a child origin (used with $origin.props.for).
+ * Extracts the attrs type from the origin's schema.
+ */
+export type AttrsFor<T extends OriginFactory<any, any>> = T extends OriginFactory<any, infer A> ? A : Record<string, any>;
+/**
+ * Attr mapping for $origin.props.for with custom mappings
+ */
+export type AttrMapping<TSource = any, TTarget = any> = {
+    [K in keyof TTarget]?: (source: TSource) => TTarget[K];
+};
+/**
+ * Valid HTML element names for $origin.for('element').
+ * At compile time, this maps to svelte/elements types.
+ */
+export type HTMLElementName = keyof HTMLElementTagNameMap | string;
+/**
+ * Placeholder type for element attrs.
+ * The real type resolution happens at compile time using svelte/elements.
+ */
+export type ElementAttrs<_K extends HTMLElementName> = Record<string, any>;
+/**
+ * An attachment function that runs when an element is attached.
+ * Can return a cleanup function that runs when the element is detached
+ * or when the attachment re-runs.
+ */
+export type AttachmentFn = (this: any, element: Element) => void | (() => void);

package/dist/runtime-inline.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Minimal inlined runtime for svelte-origin
+ *
+ * ┌─────────────────────────────────────────────────────────────────────────────┐
+ * │                                                                             │
+ * │  WHY THIS FILE EXISTS                                                       │
+ * │  ════════════════════                                                       │
+ * │                                                                             │
+ * │  When library authors publish packages using svelte-origin, they have       │
+ * │  two choices for how consumers interact with their library:                 │
+ * │                                                                             │
+ * │  ┌─────────────────────────────────────────────────────────────────────┐    │
+ * │  │  OPTION A: Zero Dependencies (Default)                              │    │
+ * │  │  ─────────────────────────────────────────────────────────────────  │    │
+ * │  │  $ svelte-package && svelte-origin                                  │    │
+ * │  │                                                                     │    │
+ * │  │  This INLINES this file (minified) into the library's dist/         │    │
+ * │  │  as `__svelte-origin-runtime.js` (~4KB). Consumers only need        │    │
+ * │  │  Svelte — NO svelte-origin dependency required.                     │    │
+ * │  │                                                                     │    │
+ * │  │  How it works:                                                      │    │
+ * │  │  1. svelte-package builds the library normally                      │    │
+ * │  │  2. post-process.ts finds `import { ... } from 'svelte-origin/...'` │    │
+ * │  │  3. Replaces with `import { ... } from './__svelte-origin-runtime'` │    │
+ * │  │  4. Copies this file (minified) to dist/__svelte-origin-runtime.js  │    │
+ * │  └─────────────────────────────────────────────────────────────────────┘    │
+ * │                                                                             │
+ * │  ┌─────────────────────────────────────────────────────────────────────┐    │
+ * │  │  OPTION B: Keep Dependency                                          │    │
+ * │  │  ─────────────────────────────────────────────────────────────────  │    │
+ * │  │  $ svelte-package && svelte-origin --dependency                     │    │
+ * │  │                                                                     │    │
+ * │  │  This keeps `import { ... } from 'svelte-origin/runtime'` as-is.    │    │
+ * │  │  Consumers must install svelte-origin as a dependency.              │    │
+ * │  │                                                                     │    │
+ * │  │  Use this when:                                                     │    │
+ * │  │  - Multiple libraries use svelte-origin (share runtime)             │    │
+ * │  │  - You need advanced runtime features                               │    │
+ * │  │  - You prefer smaller per-library bundle size                       │    │
+ * │  └─────────────────────────────────────────────────────────────────────┘    │
+ * │                                                                             │
+ * │  RELATIONSHIP TO runtime/origin.ts                                          │
+ * │  ═════════════════════════════════                                          │
+ * │                                                                             │
+ * │  This file is NOT a copy of runtime/origin.ts — it's a MINIMAL version:    │
+ * │                                                                             │
+ * │  ┌────────────────────────┬────────────────────────────────────────────┐    │
+ * │  │  runtime/origin.ts     │  runtime-inline.ts (this file)             │    │
+ * │  ├────────────────────────┼────────────────────────────────────────────┤    │
+ * │  │  ~500 lines            │  ~280 lines                                │    │
+ * │  │  Full JSDoc comments   │  No comments (stripped for size)           │    │
+ * │  │  Debug warnings        │  Minimal error messages                    │    │
+ * │  │  getMergedAttrSchema*  │  getMergedAttrSchema* (essential)          │    │
+ * │  │  __createOrigin        │  __createOrigin (essential)                │    │
+ * │  │  __attrsFor            │  __attrsFor (essential)                    │    │
+ * │  │  __createAttrs         │  __createAttrs (essential)                 │    │
+ * │  │  __createOriginInstance│  __createOriginInstance (essential)        │    │
+ * │  │  bindable, isBindable  │  (not needed at runtime)                   │    │
+ * │  │  extractAttrSchema     │  (not needed at runtime)                   │    │
+ * │  │  isAttrsFactory        │  (not needed at runtime)                   │    │
+ * │  │  generateAttrKeys      │  (not needed at runtime)                   │    │
+ * │  └────────────────────────┴────────────────────────────────────────────┘    │
+ * │                                                                             │
+ * │  The transforms compile `$origin`, `$origin.props`, `$bindable` into calls to      │
+ * │  `__createOrigin`, `__createAttrs`, `__attrsFor` with pre-computed          │
+ * │  `__attrSchema` objects — so runtime doesn't need schema extraction.        │
+ * │                                                                             │
+ * │  IMPORTANT: Changes to runtime logic must be synced between both files!     │
+ * │                                                                             │
+ * └─────────────────────────────────────────────────────────────────────────────┘
+ *
+ * @see post-process.ts - The CLI command that inlines this runtime
+ * @see runtime/origin.ts - The full runtime with all utilities
+ */
+interface AttrSchemaEntry {
+    default: unknown;
+    bindable: boolean;
+    hasDefault: boolean;
+}
+type AttrSchema = Record<string, AttrSchemaEntry>;
+interface OriginFactory<TInstance = any, TAttrs = any> {
+    (attrs?: TAttrs, ...initArgs: any[]): TInstance;
+    __origin: true;
+    __attrSchema: AttrSchema;
+    __parents: OriginFactory<any, any>[];
+    __create: (attrs: TAttrs, superInstances?: any[]) => TInstance;
+    __onInit?: (this: TInstance, ...args: any[]) => void | (() => void);
+}
+interface AttrsFactory<TAttrs = any> {
+    __attrs: true;
+    __attrSchema: AttrSchema;
+    __parents: AttrsFactory<any>[];
+}
+type AttachmentFn = (element: Element) => void | (() => void);
+export declare function __createOrigin<TInstance, TAttrs extends Record<string, any>>(config: {
+    __attrSchema: AttrSchema;
+    __parents?: OriginFactory<any, any>[];
+    __create: (attrs: TAttrs, superInstances?: any[]) => TInstance;
+    __onInit?: (this: TInstance, ...args: any[]) => void | (() => void);
+    __attachments?: Record<string, AttachmentFn>;
+}): OriginFactory<TInstance, TAttrs>;
+export declare function __attrsFor<T extends {
+    __origin: true;
+}>(factory: T, rawAttrs: Record<string, any>): Record<string, any>;
+export declare function __createAttrs<TAttrs extends Record<string, any>>(config: {
+    __attrSchema: AttrSchema;
+    __parents?: AttrsFactory<any>[];
+}): AttrsFactory<TAttrs>;
+declare const BINDABLE_MARKER: unique symbol;
+interface BindableMarker<T> {
+    [BINDABLE_MARKER]: true;
+    get: () => T;
+    set: (value: T) => void;
+}
+export declare function __bindable<T>(get: () => T, set: (value: T) => void): BindableMarker<T>;
+export declare function __createOriginInstance<T extends OriginFactory<any, any>>(factory: T, props: Record<string, any>): ReturnType<T>;
+export {};

package/dist/runtime-inline.min.js

@@ -0,0 +1 @@
+import{createAttachmentKey as P}from"svelte/attachments";function V(H,J){let C=J&&typeof J==="object"?J:{},U={},X=new Set;return new Proxy(C,{get(Q,z){if(X.has(z))return U[z];if(typeof z==="symbol")return Q[z];let Y=Q[z];if(Y===void 0&&z in H&&H[z].hasDefault)return H[z].default;return Y},set(Q,z,Y){U[z]=Y;try{Q[z]=Y}catch{X.add(z)}return!0},has(Q,z){return typeof z==="symbol"?z in Q:(z in Q)||(z in H)},ownKeys(Q){return[...new Set([...Reflect.ownKeys(Q),...Object.keys(H)])]},getOwnPropertyDescriptor(Q,z){if(typeof z==="symbol")return Object.getOwnPropertyDescriptor(Q,z);if(z in Q)return Object.getOwnPropertyDescriptor(Q,z);if(z in H)return{configurable:!0,enumerable:!0,value:H[z].hasDefault?H[z].default:void 0};return}})}function E(H,J=new Set){if(J.has(H))return{};J.add(H);let C=H.__parents||[],U={};for(let X of C)Object.assign(U,E(X,J));return Object.assign(U,H.__attrSchema),U}function S(H,J,C=new Set){let U={};for(let X of J){if(C.has(X))continue;Object.assign(U,E(X,new Set(C)))}return Object.assign(U,H),U}function k(H){let{__attrSchema:J,__parents:C=[],__create:U,__onInit:X,__attachments:Q={}}=H;function z(Y,...N){let G,q;if(Y===null||Y===void 0)G={},q=N;else if(typeof Y!=="object"||Array.isArray(Y))G={},q=[Y,...N];else G=Y,q=N;let j=S(J,C),b=V(j,G),B=C.map((Z)=>Z(b)),F=B.length===1?B[0]:B.length>1?B:void 0,D=U(b,F);if(D===null||D===void 0)throw Error("[svelte-origin] __create returned null/undefined");let R=D,T=F?new Proxy(R,{get(Z,$,L){if($ in Z){let x=Reflect.get(Z,$,L);return typeof x==="function"?x.bind(L):x}if(F&&$ in F){let x=Reflect.get(F,$,F);return typeof x==="function"?x.bind(F):x}return},has(Z,$){return $ in Z||F&&$ in F},ownKeys(Z){let $=Reflect.ownKeys(Z);return F?[...new Set([...$,...Reflect.ownKeys(F)])]:$},getOwnPropertyDescriptor(Z,$){return Reflect.getOwnPropertyDescriptor(Z,$)||(F?Reflect.getOwnPropertyDescriptor(F,$):void 0)}}):R;if(X){let Z=X.call(T,...q);if(typeof Z==="function")Object.defineProperty(T,"__cleanup",{value:Z,writable:!0,enumerable:!0,configurable:!0})}let K=new Map;for(let Z of Object.keys(Q))K.set(Z,P());return Object.defineProperty(T,"$attachments",{get(){let Z={};for(let[$,L]of Object.entries(Q))Z[K.get($)]=(x)=>L.call(T,x);for(let $ of Object.getOwnPropertySymbols(G)){let L=G[$];if(typeof L==="function")Z[$]=L}return Z},enumerable:!0,configurable:!0}),T}if(Object.defineProperty(z,"__origin",{value:!0,writable:!1,enumerable:!0}),Object.defineProperty(z,"__attrSchema",{value:J,writable:!1,enumerable:!0}),Object.defineProperty(z,"__parents",{value:C,writable:!1,enumerable:!0}),Object.defineProperty(z,"__create",{value:U,writable:!1,enumerable:!0}),X)Object.defineProperty(z,"__onInit",{value:X,writable:!1,enumerable:!0});return z}function _(H,J){let U=E(H),X={},Q=new Set,z=(G,q)=>{X[G]=q;try{return J[G]=q,!0}catch{return Q.add(G),!1}},Y={},N=(G,q)=>{if(Object.prototype.hasOwnProperty.call(Y,G))return;let j={get(){return Q.has(G)?X[G]:J[G]},enumerable:!0,configurable:!0};if(q.bindable)j.set=function(b){z(G,b)};Object.defineProperty(Y,G,j)};for(let[G,q]of Object.entries(U)){let j=J[G];if(!q.bindable||!q.hasDefault||j!==void 0)N(G,q)}for(let G of Object.getOwnPropertySymbols(J))Object.defineProperty(Y,G,{get(){return J[G]},enumerable:!1,configurable:!0});return new Proxy(Y,{get(G,q){if(typeof q==="string"){if(Q.has(q))return X[q];if(q in U)return J[q]}return q in G?G[q]:J[q]},set(G,q,j){if(typeof q==="string"&&q in U){if(!Object.prototype.hasOwnProperty.call(Y,q))N(q,U[q]);if(U[q].bindable)z(q,j);return!0}if(q in G){try{G[q]=j}catch{}return!0}try{J[q]=j}catch{if(typeof q==="string")X[q]=j,Q.add(q)}return!0},has(G,q){return q in G||q in J},ownKeys(){return[...Object.keys(Y),...Object.getOwnPropertySymbols(J)]},getOwnPropertyDescriptor(G,q){return q in G?Object.getOwnPropertyDescriptor(G,q):Object.getOwnPropertyDescriptor(J,q)}})}function w(H){return{__attrs:!0,__attrSchema:H.__attrSchema,__parents:H.__parents||[]}}var M=Symbol.for("svelte-origin:bindable");function I(H,J){return{[M]:!0,get:H,set:J}}function W(H){return H!==null&&typeof H==="object"&&M in H}function d(H,J){let C={};for(let[U,X]of Object.entries(J))if(W(X))Object.defineProperty(C,U,{get(){return X.get()},set(Q){X.set(Q)},enumerable:!0,configurable:!0});else Object.defineProperty(C,U,{get(){return X},enumerable:!0,configurable:!0});return H(C)}export{d as __createOriginInstance,k as __createOrigin,w as __createAttrs,I as __bindable,_ as __attrsFor};

package/dist/schema-resolver.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared schema resolution logic for svelte-origin
+ *
+ * This module provides the core schema resolution functionality used by both
+ * the Svelte preprocessor and the Vite plugin. Extracting this into a shared
+ * module ensures:
+ *
+ * 1. Single source of truth - changes reflect in both preprocessor and plugin
+ * 2. Reduced code duplication - ~400 lines of duplicated code eliminated
+ * 3. Consistent behavior - both tools resolve schemas identically
+ *
+ * The schema resolver reads origin/attrs factory definitions from source files
+ * and recursively resolves parent schemas to build complete prop type information.
+ */
+import { type ParsedOriginSchema, type ParsedAttrInfo, type SchemaResolver } from './transform/schema';
+export type { ParsedOriginSchema, ParsedAttrInfo, SchemaResolver };
+export interface SchemaResolverOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Resolved alias mappings for import resolution */
+    aliases?: Record<string, string>;
+    /**
+     * Pre-cached imports from the module script.
+     * Maps local name (e.g., "TableState" or alias) to import path.
+     * This enables schema resolution when the import is in the module script
+     * but the $origin.component() call is in the component script.
+     */
+    moduleImports?: Map<string, string>;
+}
+/**
+ * Invalidate cache entries for a specific file.
+ * This is called when a file changes to ensure stale schemas are not served.
+ *
+ * @param filePath The absolute path of the file that changed
+ * @param cache The schema cache to invalidate entries from
+ */
+export declare function invalidateCacheForFile(filePath: string, cache: Map<string, ParsedOriginSchema | null>): void;
+/**
+ * Reset mtime tracking for testing purposes.
+ * This clears all cached mtime data to ensure clean test state.
+ */
+export declare function resetMtimeTracking(): void;
+/**
+ * Resolve a schema from an import path, recursively resolving parent schemas.
+ * This is the core schema resolution logic shared between preprocessor and plugin.
+ */
+export declare function resolveSchema(importPath: string, exportName: string, importerId: string, cache: Map<string, ParsedOriginSchema | null>, options?: SchemaResolverOptions): Promise<ParsedOriginSchema | null>;
+/**
+ * Resolve an $origin.props factory schema from an import path.
+ * Similar to resolveSchema but handles $origin.props factories instead of $origin.
+ */
+export declare function resolveAttrsSchema(importPath: string, exportName: string, importerId: string, cache: Map<string, ParsedOriginSchema | null>, options?: SchemaResolverOptions): Promise<ParsedOriginSchema | null>;
+/**
+ * Create a schema resolver bound to a specific file and cache.
+ * This creates the SchemaResolver interface expected by transform functions.
+ *
+ * Resolution priority when importPath is null:
+ * 1. Check moduleImports (from preprocessor's module script cache)
+ * 2. Attempt sibling file resolution (guessing by factory name)
+ */
+export declare function createSchemaResolver(importerId: string, cache: Map<string, ParsedOriginSchema | null>, options?: SchemaResolverOptions): SchemaResolver;

package/dist/shared-state.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared state between preprocessor and plugin
+ *
+ * This module allows the preprocessor to signal to the plugin that it's active,
+ * so the plugin knows whether it should handle .svelte files or not.
+ *
+ * It also shares output settings from the plugin to the preprocessor,
+ * so both can write transformed output to the same directory.
+ *
+ * This works because both the preprocessor (via svelte.config.js) and the plugin
+ * (via vite.config.ts) run in the same Node.js process during Vite startup.
+ */
+/**
+ * Shared output settings from the plugin
+ */
+export interface OutputSettings {
+    /** Whether to output transformed files */
+    outputTransformed: boolean;
+    /** Directory for transformed output (absolute path) */
+    outputDir?: string;
+    /** Enable debug logging */
+    debug: boolean;
+}
+/**
+ * Mark the preprocessor as active.
+ * Called by svelteOriginPreprocess() when it initializes.
+ */
+export declare function markPreprocessorActive(): void;
+/**
+ * Check if the preprocessor is active.
+ * Called by svelteOrigin() plugin to decide if it should handle .svelte files.
+ */
+export declare function isPreprocessorActive(): boolean;
+/**
+ * Set output settings from the plugin.
+ * Called by svelteOrigin() plugin during initialization.
+ */
+export declare function setOutputSettings(settings: Partial<OutputSettings>): void;
+/**
+ * Get current output settings.
+ * Used by the preprocessor to write transformed output.
+ */
+export declare function getOutputSettings(): OutputSettings;
+/**
+ * Reset the state (for testing purposes only)
+ */
+export declare function resetState(): void;