sudachi-ts 0.1.20-beta.7 → 0.1.22

package/README.md

@@ -12,10 +12,10 @@ TypeScript port of [Sudachi](https://github.com/WorksApplications/Sudachi) Japan
 - **Binary Dictionary Compatibility**: Load and use pre-built Sudachi dictionaries
 - **Dynamic Plugin System**: Extensible architecture with runtime plugin loading
 - **Dictionary Building**: Complete CSV to binary dictionary conversion
-- **Sentence Detection**: Multi-sentence text processing
-- **UTF-8 Handling**: Proper Japanese text normalization and character encoding
-- **POS Matching**: Flexible part-of-speech filtering and matching
-- **Counter Alias Recovery**: Resolves numeric kana counters such as `1こ` to the canonical counter lattice before best-path selection
+- **Sentence Detection**: Multi-sentence text processing
+- **UTF-8 Handling**: Proper Japanese text normalization and character encoding
+- **POS Matching**: Flexible part-of-speech filtering and matching
+- **Counter Alias Recovery**: Resolves numeric kana counters such as `1こ` to the canonical counter lattice before best-path selection
 
 ## Requirements
 
@@ -106,7 +106,7 @@ const config = await loadConfig('./sudachi.json');
 const dict = Dictionary.create();
 ```
 
-Example `sudachi.json`:
+Example `sudachi.json`:
 
 ```json
 {
@@ -121,31 +121,31 @@ Example `sudachi.json`:
       }
     }
   ]
-}
-```
-
-For non-absolute file references in config (dictionary files, plugin module paths,
-and built-in plugin file settings), Sudachi-TS tries paths relative to the config
-file first, then relative to the current working directory.
-
-By default, Sudachi-TS enables a built-in compound-particle lexicon
-(`"enableDefaultCompoundParticles": true`) so forms such as `かも`, `のか`,
-and `だから` are tokenized as single morphemes. Set it to `false` to disable:
+}
+```
+
+For non-absolute file references in config (dictionary files, plugin module paths,
+and built-in plugin file settings), Sudachi-TS tries paths relative to the config
+file first, then relative to the current working directory.
+
+By default, Sudachi-TS enables a built-in compound-particle lexicon
+(`"enableDefaultCompoundParticles": true`) so forms such as `かも`, `のか`,
+and `だから` are tokenized as single morphemes. Set it to `false` to disable:
 
 ```json
-{
-  "enableDefaultCompoundParticles": false
-}
-```
-
-The default OOV plugin stack also injects counter aliases in numeric contexts,
-so kana counters such as `りんごを1こください。` are analyzed as
-`りんご / を / 1 / こ / ください / 。` with the counter normalized to `個`
-instead of falling through to unrelated dictionary entries.
-
-## Working with Morphemes
-
-Access detailed morpheme information:
+{
+  "enableDefaultCompoundParticles": false
+}
+```
+
+The default OOV plugin stack also injects counter aliases in numeric contexts,
+so kana counters such as `りんごを1こください。` are analyzed as
+`りんご / を / 1 / こ / ください / 。` with the counter normalized to `個`
+instead of falling through to unrelated dictionary entries.
+
+## Working with Morphemes
+
+Access detailed morpheme information:
 
 ```typescript
 const morpheme = result[0];
@@ -171,34 +171,34 @@ console.log(morpheme.end());
 console.log(morpheme.length());
 
 // Check morpheme properties
-console.log(morpheme.isOov()); // True if out-of-vocabulary
-```
-
-## Public Dictionary Access
-
-`DictionaryFactory` returns a public `Dictionary` that now exposes stable
-dictionary metadata APIs without requiring internal imports.
-
-```typescript
-import { DictionaryFactory } from 'sudachi-ts';
-
-const dictionary = await new DictionaryFactory().create('./sudachi.json');
-
-const grammar = dictionary.getGrammar();
-const lexicon = dictionary.getLexicon();
-
-const kyotoId = lexicon.getWordId('京都', 3, 'キョウト');
-const kyotoInfo = lexicon.getWordInfo(kyotoId);
-
-console.log(grammar.getPartOfSpeechString(kyotoInfo.getPOSId()));
-console.log(kyotoInfo.getSynonymGroupIds());
-```
-
-When user dictionaries are configured, `dictionary.getLexicon()` exposes the
-merged lexicon view used by tokenization, so downstream plugins can look up both
-system and user dictionary entries through the same public API.
-
-## Splitting Morphemes
+console.log(morpheme.isOov()); // True if out-of-vocabulary
+```
+
+## Public Dictionary Access
+
+`DictionaryFactory` returns a public `Dictionary` that now exposes stable
+dictionary metadata APIs without requiring internal imports.
+
+```typescript
+import { DictionaryFactory } from 'sudachi-ts';
+
+const dictionary = await new DictionaryFactory().create('./sudachi.json');
+
+const grammar = dictionary.getGrammar();
+const lexicon = dictionary.getLexicon();
+
+const kyotoId = lexicon.getWordId('京都', 3, 'キョウト');
+const kyotoInfo = lexicon.getWordInfo(kyotoId);
+
+console.log(grammar.getPartOfSpeechString(kyotoInfo.getPOSId()));
+console.log(kyotoInfo.getSynonymGroupIds());
+```
+
+When user dictionaries are configured, `dictionary.getLexicon()` exposes the
+merged lexicon view used by tokenization, so downstream plugins can look up both
+system and user dictionary entries through the same public API.
+
+## Splitting Morphemes
 
 Use the split method to change granularity:
 
@@ -221,18 +221,18 @@ import { SentenceDetector } from 'sudachi-ts/sentdetect/sentenceDetector.js';
 
 const sentences = tokenizer.tokenizeSentences('東京都は日本の首都です。大阪は商業都市です。');
 
-for (const sentence of sentences) {
-  console.log('--- Sentence ---');
-  for (const morpheme of sentence) {
-    console.log(morpheme.surface());
-  }
-}
-```
-
-`tokenizeSentences(...)` treats standalone quoted dialogue endings (for example
-`「...！」`) as sentence boundaries, but keeps quoted speech attached to following
-reporting clauses such as `「...。」と言いました。`. It also skips leading
-inter-sentence whitespace such as newlines before tokenization.
+for (const sentence of sentences) {
+  console.log('--- Sentence ---');
+  for (const morpheme of sentence) {
+    console.log(morpheme.surface());
+  }
+}
+```
+
+`tokenizeSentences(...)` treats standalone quoted dialogue endings (for example
+`「...！」`) as sentence boundaries, but keeps quoted speech attached to following
+reporting clauses such as `「...。」と言いました。`. It also skips leading
+inter-sentence whitespace such as newlines before tokenization.
 
 Lazy sentence processing for streaming:
 
@@ -305,61 +305,26 @@ const plugin = await loader.loadInputTextPlugin(
 
 See [PLUGINS.md](./PLUGINS.md) for detailed plugin development guide.
 
-Quick local comparison for the PoC token chunker plugin:
-
-```bash
-npm exec tsx examples/token-chunker-plugin.ts /path/to/system.dic "東京大学"
-```
-
-This example prints each token as `surface/reading` so the chunking impact on
-readings is visible in the baseline vs plugin outputs.
-`TokenChunkerPlugin` is designed and validated against the full Sudachi system
-dictionary (`system_full.dic` / `system.dic`), so prefer full-dictionary checks
-when adding or tuning chunk rules.
-`TokenChunkerPlugin` requires `enableDefaultCompoundParticles: true`. Dictionary
-creation throws an error when this plugin is configured with default compound
-particles disabled.
-`TokenChunkerPlugin` is intended for `SplitMode.C` tokenization; calling
-`tokenize(SplitMode.A, ...)` or `tokenize(SplitMode.B, ...)` with this plugin
-enabled throws an error.
-When the lattice already contains a lexicalized compound candidate, the chunker
-also prefers learner-facing noun compounds such as `学校` over split analyses
-like `学` + `校`.
-The chunker also handles polite progressive colloquial forms where `て/で` is
-an auxiliary (`てる/でる`) such as `残ってます` and `残ってますよ`, plus
-polite colloquial contraction forms like `太っちゃいます` and
-`太っちゃいますよ`, and colloquial `〜てく` past contractions like
-`持ってった`, colloquial `〜ておく` past contractions like `やめといた`, plus discourse chunks like `だなって` and contractions like
-`してんだ`, `あっけど`, particle chunks like `とか`, sentence-final turns like `いいよな`, copula quote
-spans like `ヒマだって`, and quoted reason clauses like `言ってたし`. It also chunks causative auxiliaries such as
-`打たせる` / `内させる` into a single learner-facing token, along with
- polite connective forms such as `込めまして`, negative connective forms such as
-`遣わなくて`, lexicalized adverbials such as `別に`, conversational turns such as
-`いいよ`, and causative te-forms such as `させて`. For learner-facing output it
-also prefers more natural alternate dictionary readings when the lattice already
-contains them, such as `明日` -> `アシタ`, `明後日` -> `アサッテ`, and
-`私` -> `ワタシ`, and it supports additional `preferredReadings` overrides
-via plugin settings using entries like `"私=ワタシ"`. It also normalizes
-mixed-script weekday compounds such as `火よう日` -> `カヨウビ`.
-The core tokenizer also rewrites sentence-ending ambiguities such as
-`ね | こと | ね` into `ねこ | と | ね` when the lattice supports that path.
-
-## Dictionary Building
+
+The core tokenizer also rewrites sentence-ending ambiguities such as
+`ね | こと | ね` into `ねこ | と | ね` when the lattice supports that path.
+
+## Dictionary Building
 
 Build binary dictionaries from CSV source:
 
-```typescript
-import { systemBuilder } from 'sudachi-ts/dictionary-build';
-
-const builder = systemBuilder();
-
-// Add lexicon entries from CSV
-await builder.matrix(matrixDefContents);
-await builder.lexicon(lexiconCsvContents, 'lexicon.csv');
-
-// Build binary dictionary
-const { buffer } = await builder.build();
-```
+```typescript
+import { systemBuilder } from 'sudachi-ts/dictionary-build';
+
+const builder = systemBuilder();
+
+// Add lexicon entries from CSV
+await builder.matrix(matrixDefContents);
+await builder.lexicon(lexiconCsvContents, 'lexicon.csv');
+
+// Build binary dictionary
+const { buffer } = await builder.build();
+```
 
 CSV format:
 
@@ -395,23 +360,23 @@ See [CONFIG.md](./CONFIG.md) for detailed configuration options.
 
 ## Development
 
-```bash
-# Clone repository
-git clone https://github.com/your-org/sudachi-ts.git
-cd sudachi-ts
-
-# Install dependencies
-npm install
-
-# Type check
-npm run typecheck
-
-# Run tests
-npm test
-
-# Lint
-npm run check:fix
-```
+```bash
+# Clone repository
+git clone https://github.com/your-org/sudachi-ts.git
+cd sudachi-ts
+
+# Install dependencies
+npm install
+
+# Type check
+npm run typecheck
+
+# Run tests
+npm test
+
+# Lint
+npm run check:fix
+```
 
 ## Architecture
 

package/build/src/dictionary/dictionaryFactory.js

@@ -6,12 +6,6 @@ import { PluginLoader } from '../plugins/loader.js';
 import { BinaryDictionary } from './binaryDictionary.js';
 import { loadDefaultCompoundLexicon } from './defaultCompoundLexicon.js';
 import { LexiconSet } from './lexiconSet.js';
-function isTokenChunkerPlugin(className) {
-    if (className === 'com.worksap.nlp.sudachi.TokenChunkerPlugin') {
-        return true;
-    }
-    return className.split('.').pop() === 'TokenChunkerPlugin';
-}
 export class DictionaryFactory {
     async create(configPath, customConfig) {
         const config = customConfig || (await loadConfig(configPath));
@@ -52,6 +46,15 @@ export class DictionaryFactory {
         }
         const loader = new PluginLoader(anchor);
         const defaultConfig = Config.parse(DEFAULT_CONFIG_JSON).setAnchor(anchor);
+        let editConnectionPluginConfs = config.getPlugins('editConnectionCostPlugin');
+        if (!editConnectionPluginConfs || editConnectionPluginConfs.length === 0) {
+            editConnectionPluginConfs = defaultConfig.getPlugins('editConnectionCostPlugin');
+        }
+        if (editConnectionPluginConfs && editConnectionPluginConfs.length > 0) {
+            for (const loaded of await loader.loadEditConnectionCostPlugins(editConnectionPluginConfs, grammar, lexicon)) {
+                loaded.plugin.edit(grammar);
+            }
+        }
         let inputTextPluginConfs = config.getPlugins('inputTextPlugin');
         if (!inputTextPluginConfs || inputTextPluginConfs.length === 0) {
             inputTextPluginConfs = defaultConfig.getPlugins('inputTextPlugin');
@@ -82,10 +85,6 @@ export class DictionaryFactory {
         if (!pathRewritePluginConfs || pathRewritePluginConfs.length === 0) {
             pathRewritePluginConfs = defaultConfig.getPlugins('pathRewritePlugin');
         }
-        if (!enableDefaultCompoundParticles &&
-            (pathRewritePluginConfs || []).some((conf) => isTokenChunkerPlugin(conf.className))) {
-            throw new Error('TokenChunkerPlugin is only compatible when enableDefaultCompoundParticles is true.');
-        }
         const pathRewritePlugins = (await loader.loadPathRewritePlugins(pathRewritePluginConfs || [], grammar)).map((p) => p.plugin);
         return new Dictionary(grammar, lexicon, inputTextPlugins, oovProviderPlugins, pathRewritePlugins);
     }

package/build/src/index.d.ts

@@ -24,7 +24,7 @@ export { DEPTH, MAX_COMPONENT_LENGTH, POS } from './dictionary/pos.js';
 export { PartialPOS, PosMatcher } from './dictionary/posMatcher.js';
 export { WordInfo } from './dictionary/wordInfo.js';
 export { DoubleArray } from './dictionary-build/doubleArray.js';
-export { EditConnectionCostPlugin, InputTextPlugin, type LoadedPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, } from './plugins/index.js';
+export { EditConnectionCostPlugin, InputTextPlugin, type LoadedPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, TargetedConnectionCostPlugin, } from './plugins/index.js';
 export type { NonBreakChecker } from './sentdetect/sentenceDetector.js';
 export { DEFAULT_LIMIT, SentenceDetector, } from './sentdetect/sentenceDetector.js';
 export { applyMask, dic, dicIdMask, MAX_DIC_ID, MAX_WORD_ID, make, word, } from './utils/wordId.js';

package/build/src/index.js

@@ -15,7 +15,7 @@ export { DEPTH, MAX_COMPONENT_LENGTH, POS } from './dictionary/pos.js';
 export { PartialPOS, PosMatcher } from './dictionary/posMatcher.js';
 export { WordInfo } from './dictionary/wordInfo.js';
 export { DoubleArray } from './dictionary-build/doubleArray.js';
-export { EditConnectionCostPlugin, InputTextPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, } from './plugins/index.js';
+export { EditConnectionCostPlugin, InputTextPlugin, MorphemeFormatterPlugin, OovProviderPlugin, PathRewritePlugin, Plugin, PluginLoader, TargetedConnectionCostPlugin, } from './plugins/index.js';
 export { DEFAULT_LIMIT, SentenceDetector, } from './sentdetect/sentenceDetector.js';
 export { applyMask, dic, dicIdMask, MAX_DIC_ID, MAX_WORD_ID, make, word, } from './utils/wordId.js';
 export { addNth, hasNth, MAX_LENGTH, nth } from './utils/wordMask.js';

package/build/src/plugins/base.d.ts

@@ -1,4 +1,4 @@
-import type { Settings } from '../config/settings.js';
+import { Settings } from '../config/settings.js';
 export declare abstract class Plugin {
     protected settings: Settings;
     constructor();

package/build/src/plugins/base.js

@@ -1,7 +1,8 @@
+import { Settings } from '../config/settings.js';
 export class Plugin {
     settings;
     constructor() {
-        this.settings = { getString: () => null };
+        this.settings = Settings.empty();
     }
     setSettings(settings) {
         this.settings = settings;

package/build/src/plugins/connection/base.d.ts

@@ -1,7 +1,8 @@
 import type { Grammar } from '../../dictionary/grammar.js';
+import type { Lexicon } from '../../dictionary/lexicon.js';
 import { Plugin } from '../base.js';
 export declare abstract class EditConnectionCostPlugin extends Plugin {
-    setUp(_grammar: Grammar): void;
+    setUp(_grammar: Grammar, _lexicon?: Lexicon): void;
     abstract edit(grammar: Grammar): void;
     inhibitConnection(grammar: Grammar, left: number, right: number): void;
 }

package/build/src/plugins/connection/base.js

@@ -1,6 +1,6 @@
 import { Plugin } from '../base.js';
 export class EditConnectionCostPlugin extends Plugin {
-    setUp(_grammar) { }
+    setUp(_grammar, _lexicon) { }
     inhibitConnection(grammar, left, right) {
         grammar.setConnectCost(left, right, grammar.INHIBITED_CONNECTION);
     }

package/build/src/plugins/connection/targetedConnectionCostPlugin.d.ts

@@ -0,0 +1,13 @@
+import type { Grammar } from '../../dictionary/grammar.js';
+import type { Lexicon } from '../../dictionary/lexicon.js';
+import { EditConnectionCostPlugin } from './base.js';
+export declare class TargetedConnectionCostPlugin extends EditConnectionCostPlugin {
+    private rules;
+    setUp(grammar: Grammar, lexicon?: Lexicon): void;
+    edit(grammar: Grammar): void;
+    private resolveRule;
+    private resolveWordId;
+    private normalizePos;
+    private requireConnectionRule;
+    private requireEntryTarget;
+}

package/build/src/plugins/connection/targetedConnectionCostPlugin.js

@@ -0,0 +1,102 @@
+import { EditConnectionCostPlugin } from './base.js';
+export class TargetedConnectionCostPlugin extends EditConnectionCostPlugin {
+    rules = [];
+    setUp(grammar, lexicon) {
+        if (!lexicon) {
+            throw new Error('TargetedConnectionCostPlugin requires the lexicon during setup');
+        }
+        const rawRules = this.settings.toObject().rules;
+        if (!Array.isArray(rawRules) || rawRules.length === 0) {
+            throw new Error('rules is undefined');
+        }
+        this.rules = rawRules.map((rule, index) => this.resolveRule(grammar, lexicon, rule, index + 1));
+    }
+    edit(grammar) {
+        for (const rule of this.rules) {
+            grammar.setConnectCost(rule.leftRightId, rule.rightLeftId, rule.cost);
+        }
+    }
+    resolveRule(grammar, lexicon, rule, ruleIndex) {
+        const parsedRule = this.requireConnectionRule(rule, ruleIndex);
+        const leftWordId = this.resolveWordId(grammar, lexicon, parsedRule.left, 'rule', ruleIndex, 'left');
+        const rightWordId = this.resolveWordId(grammar, lexicon, parsedRule.right, 'rule', ruleIndex, 'right');
+        return {
+            leftRightId: lexicon.getRightId(leftWordId),
+            rightLeftId: lexicon.getLeftId(rightWordId),
+            cost: parsedRule.cost,
+        };
+    }
+    resolveWordId(grammar, lexicon, target, ruleLabel, ruleIndex, side) {
+        if (typeof target.surface !== 'string' || target.surface === '') {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} surface must be a non-empty string`);
+        }
+        if (typeof target.reading !== 'string' || target.reading === '') {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} reading must be a non-empty string`);
+        }
+        const pos = this.normalizePos(target.pos, ruleLabel, ruleIndex, side);
+        const posId = grammar.getPartOfSpeechId(pos);
+        if (posId < 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} POS ${pos.join(',')} was not found in the loaded grammar`);
+        }
+        const wordId = lexicon.getWordId(target.surface, posId, target.reading);
+        if (wordId < 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} entry ${target.surface} (${pos.join(',')} / ${target.reading}) was not found in the loaded lexicon`);
+        }
+        return wordId;
+    }
+    normalizePos(pos, ruleLabel, ruleIndex, side) {
+        if (!Array.isArray(pos) || pos.length === 0) {
+            throw new Error(`${ruleLabel} ${ruleIndex} ${side} pos must be a non-empty string list`);
+        }
+        const normalized = pos.map((item) => {
+            if (typeof item !== 'string') {
+                throw new Error(`${ruleLabel} ${ruleIndex} ${side} pos must contain only strings`);
+            }
+            return item;
+        });
+        while (normalized.length < 6) {
+            normalized.push('*');
+        }
+        return normalized.slice(0, 6);
+    }
+    requireConnectionRule(rule, ruleIndex) {
+        if (typeof rule !== 'object' || rule === null) {
+            throw new Error(`rule ${ruleIndex} must be an object`);
+        }
+        const obj = rule;
+        const left = obj.left;
+        const right = obj.right;
+        const cost = obj.cost;
+        if (typeof cost !== 'number') {
+            throw new Error(`rule ${ruleIndex} cost must be a number`);
+        }
+        return {
+            left: this.requireEntryTarget(left, ruleIndex, 'left'),
+            right: this.requireEntryTarget(right, ruleIndex, 'right'),
+            cost,
+        };
+    }
+    requireEntryTarget(value, ruleIndex, side) {
+        if (typeof value !== 'object' || value === null) {
+            throw new Error(`rule ${ruleIndex} ${side} must be an object`);
+        }
+        const obj = value;
+        const surface = obj.surface;
+        const pos = obj.pos;
+        const reading = obj.reading;
+        if (typeof surface !== 'string') {
+            throw new Error(`rule ${ruleIndex} ${side} surface must be a string`);
+        }
+        if (!Array.isArray(pos)) {
+            throw new Error(`rule ${ruleIndex} ${side} pos must be a string list`);
+        }
+        if (typeof reading !== 'string') {
+            throw new Error(`rule ${ruleIndex} ${side} reading must be a string`);
+        }
+        return {
+            surface,
+            pos: pos,
+            reading,
+        };
+    }
+}

package/build/src/plugins/index.d.ts

@@ -1,6 +1,7 @@
 export { Plugin } from './base.js';
 export { EditConnectionCostPlugin } from './connection/base.js';
 export { InhibitConnectionPlugin } from './connection/inhibitConnectionPlugin.js';
+export { TargetedConnectionCostPlugin } from './connection/targetedConnectionCostPlugin.js';
 export { MorphemeFormatterPlugin } from './formatter/base.js';
 export { SimpleMorphemeFormatter } from './formatter/simpleMorphemeFormatter.js';
 export { WordSegmentationFormatter } from './formatter/wordSegmentationFormatter.js';
@@ -17,4 +18,3 @@ export { SimpleOovProviderPlugin } from './oov/simpleOovProviderPlugin.js';
 export { PathRewritePlugin } from './pathRewrite/base.js';
 export { JoinKatakanaOovPlugin } from './pathRewrite/joinKatakanaOovPlugin.js';
 export { JoinNumericPlugin } from './pathRewrite/joinNumericPlugin.js';
-export { TokenChunkerPlugin } from './pathRewrite/tokenChunkerPlugin.js';

package/build/src/plugins/index.js

@@ -1,6 +1,7 @@
 export { Plugin } from './base.js';
 export { EditConnectionCostPlugin } from './connection/base.js';
 export { InhibitConnectionPlugin } from './connection/inhibitConnectionPlugin.js';
+export { TargetedConnectionCostPlugin } from './connection/targetedConnectionCostPlugin.js';
 export { MorphemeFormatterPlugin } from './formatter/base.js';
 export { SimpleMorphemeFormatter } from './formatter/simpleMorphemeFormatter.js';
 export { WordSegmentationFormatter } from './formatter/wordSegmentationFormatter.js';
@@ -17,4 +18,3 @@ export { SimpleOovProviderPlugin } from './oov/simpleOovProviderPlugin.js';
 export { PathRewritePlugin } from './pathRewrite/base.js';
 export { JoinKatakanaOovPlugin } from './pathRewrite/joinKatakanaOovPlugin.js';
 export { JoinNumericPlugin } from './pathRewrite/joinNumericPlugin.js';
-export { TokenChunkerPlugin } from './pathRewrite/tokenChunkerPlugin.js';

package/build/src/plugins/loader.d.ts

@@ -1,6 +1,7 @@
 import { PathAnchor } from '../config/pathAnchor.js';
 import type { Settings } from '../config/settings.js';
 import type { Grammar } from '../dictionary/grammar.js';
+import type { Lexicon } from '../dictionary/lexicon.js';
 import type { Plugin } from './base.js';
 import type { EditConnectionCostPlugin } from './connection/base.js';
 import type { MorphemeFormatterPlugin } from './formatter/base.js';
@@ -11,6 +12,10 @@ export interface LoadedPlugin<T extends Plugin> {
     plugin: T;
     className: string;
 }
+type PluginConfig = {
+    className: string;
+    settings: Settings;
+};
 export declare class PluginLoader {
     private readonly anchor;
     constructor(anchor?: PathAnchor);
@@ -19,27 +24,16 @@ export declare class PluginLoader {
     loadPathRewritePlugin(className: string, settings: Settings): Promise<LoadedPlugin<PathRewritePlugin>>;
     loadEditConnectionCostPlugin(className: string, settings: Settings): Promise<LoadedPlugin<EditConnectionCostPlugin>>;
     loadMorphemeFormatterPlugin(className: string, settings: Settings): Promise<LoadedPlugin<MorphemeFormatterPlugin>>;
-    loadInputTextPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<InputTextPlugin>[]>;
-    loadOovProviderPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<OovProviderPlugin>[]>;
-    loadPathRewritePlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<PathRewritePlugin>[]>;
-    loadEditConnectionCostPlugins(configs: {
-        className: string;
-        settings: Settings;
-    }[], grammar: Grammar): Promise<LoadedPlugin<EditConnectionCostPlugin>[]>;
+    loadInputTextPlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<InputTextPlugin>[]>;
+    loadOovProviderPlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<OovProviderPlugin>[]>;
+    loadPathRewritePlugins(configs: PluginConfig[], grammar: Grammar): Promise<LoadedPlugin<PathRewritePlugin>[]>;
+    loadEditConnectionCostPlugins(configs: PluginConfig[], grammar: Grammar, lexicon: Lexicon): Promise<LoadedPlugin<EditConnectionCostPlugin>[]>;
     private loadPlugin;
+    private loadConfiguredPlugins;
     private findPluginClass;
     private isPluginConstructor;
     private resolveClassSpecifier;
     private isPathLikeSpecifier;
-    private isBuiltIn;
     private getBuiltIn;
 }
+export {};