yomitan-core 0.1.0

package/dist/anki.d.cts

@@ -0,0 +1,751 @@
+import { ApiReflectResult, CanAddNotesDetail, CardId, CardInfo, Note, NoteId, NoteInfo, SerializableObject } from "./core-BUpclilG.cjs";
+import { DictionaryEntry, InflectionRuleChainCandidate, KanjiDictionaryEntry, Tag$1 as Tag, TermDictionaryEntry, TermGlossaryContent } from "./dictionary-D7l-qFt1.cjs";
+
+//#region src/anki/anki-connect.d.ts
+/**
+* This class controls communication with Anki via the AnkiConnect plugin.
+*/
+/**
+ * This class controls communication with Anki via the AnkiConnect plugin.
+ */
+declare class AnkiConnect {
+  private _enabled;
+  private _server;
+  private _localVersion;
+  private _remoteVersion;
+  private _versionCheckPromise;
+  private _apiKey;
+  constructor(config?: {
+    server?: string;
+    apiKey?: string;
+  });
+  get server(): string | null;
+  set server(value: string);
+  get enabled(): boolean;
+  set enabled(value: boolean);
+  get apiKey(): string | null;
+  set apiKey(value: string | null);
+  /**
+   * Checks whether a connection to AnkiConnect can be established.
+   */
+  isConnected(): Promise<boolean>;
+  /**
+   * Gets the AnkiConnect API version number.
+   */
+  getVersion(): Promise<number | null>;
+  addNote(note: Note): Promise<NoteId | null>;
+  addNotes(notes: Note[]): Promise<(number | null)[] | null>;
+  updateNoteFields(noteWithId: Note & {
+    id?: NoteId;
+  }): Promise<null>;
+  canAddNotes(notes: Note[]): Promise<boolean[]>;
+  canAddNotesWithErrorDetail(notes: Note[]): Promise<CanAddNotesDetail[]>;
+  notesInfo(noteIds: NoteId[]): Promise<(NoteInfo | null)[]>;
+  cardsInfo(cardIds: CardId[]): Promise<(CardInfo | null)[]>;
+  getDeckNames(): Promise<string[]>;
+  getModelNames(): Promise<string[]>;
+  getModelFieldNames(modelName: string): Promise<string[]>;
+  guiBrowse(query: string): Promise<CardId[]>;
+  guiBrowseNote(noteId: NoteId): Promise<CardId[]>;
+  guiBrowseNotes(noteIds: NoteId[]): Promise<CardId[]>;
+  guiEditNote(noteId: NoteId): Promise<void>;
+  /**
+   * Stores a file with the specified base64-encoded content inside Anki's media folder.
+   */
+  storeMediaFile(fileName: string, content: string): Promise<string | null>;
+  /**
+   * Finds notes matching a query.
+   */
+  findNotes(query: string): Promise<NoteId[]>;
+  findNoteIds(notes: Note[]): Promise<NoteId[][]>;
+  suspendCards(cardIds: CardId[]): Promise<boolean>;
+  findCards(query: string): Promise<CardId[]>;
+  findCardsForNote(noteId: NoteId): Promise<CardId[]>;
+  /**
+   * Gets information about the AnkiConnect APIs available.
+   */
+  apiReflect(scopes: string[], actions?: string[] | null): Promise<ApiReflectResult>;
+  /**
+   * Checks whether a specific API action exists.
+   */
+  apiExists(action: string): Promise<boolean>;
+  /**
+   * Checks if a specific error object corresponds to an unsupported action.
+   */
+  isErrorUnsupportedAction(error: Error): boolean;
+  /**
+   * Makes Anki sync.
+   */
+  makeAnkiSync(): Promise<unknown | null>;
+  private _checkVersion;
+  private _invoke;
+  private _invokeMulti;
+  private _escapeQuery;
+  private _fieldsToQuery;
+  private _getDuplicateScopeFromNote;
+  private _getNoteQuery;
+  private _getVersion;
+  private _createError;
+  private _createUnexpectedResultError;
+  private _getTypeName;
+  private _normalizeArray;
+  private _normalizeNoteInfoArray;
+  private _normalizeCardInfoArray;
+  private _normalizeCanAddNotesWithErrorDetailArray;
+} //#endregion
+//#region src/anki/anki-note-builder.d.ts
+
+//# sourceMappingURL=anki-connect.d.ts.map
+/**
+ * Represents a template rendering result.
+ */
+type RenderResult = {
+  result: string;
+  requirements: Requirement[];
+};
+/**
+ * Represents a rendering response from renderMulti.
+ */
+type RenderMultiResponse = {
+  result?: RenderResult;
+  error?: SerializedError;
+};
+type SerializedError = {
+  name?: string;
+  message?: string;
+  stack?: string;
+  data?: unknown;
+};
+/**
+ * Interface for a template renderer that can be injected into AnkiNoteBuilder.
+ */
+interface TemplateRenderer {
+  getModifiedData(data: {
+    marker: string;
+    commonData: CommonData;
+  }, type: string): Promise<NoteData>;
+  renderMulti(items: RenderMultiItem[]): Promise<RenderMultiResponse[]>;
+}
+type RenderMultiItem = {
+  template: string;
+  templateItems: RenderMultiTemplateItem$1[];
+};
+type RenderMultiTemplateItem$1 = {
+  type: string;
+  commonData: CommonData;
+  datas: PartialRenderData$1[];
+};
+type PartialRenderData$1 = {
+  marker: string;
+};
+/**
+ * Common data passed through the template rendering process.
+ */
+type CommonData = {
+  dictionaryEntry: DictionaryEntry;
+  cardFormat: AnkiCardFormat;
+  context: Context;
+  resultOutputMode: ResultOutputMode;
+  glossaryLayoutMode: GlossaryLayoutMode;
+  compactTags: boolean;
+  media?: Media;
+  dictionaryStylesMap: Map<string, string>;
+};
+type AnkiCardFormat = {
+  deck: string;
+  model: string;
+  fields: {
+    [fieldName: string]: {
+      value: string;
+    };
+  };
+};
+type Context = {
+  url: string;
+  sentence?: {
+    text: string;
+    offset: number;
+  };
+  query: string;
+  fullQuery: string;
+  documentTitle?: string;
+};
+type ResultOutputMode = 'group' | 'merge' | 'split';
+type GlossaryLayoutMode = 'default' | 'compact' | 'compact-popup-anki';
+type MediaObject = {
+  value: string;
+};
+type Media = {
+  audio?: MediaObject;
+  screenshot?: MediaObject;
+  clipboardImage?: MediaObject;
+  clipboardText?: MediaObject;
+  popupSelectionText?: MediaObject;
+  textFurigana: TextFuriganaSegment[];
+  dictionaryMedia: DictionaryMedia;
+};
+type TextFuriganaSegment = {
+  text: string;
+  readingMode: TextFuriganaReadingMode | null;
+  detailsHtml: MediaObject;
+  detailsPlain: MediaObject;
+};
+type TextFuriganaReadingMode = 'hiragana' | 'katakana';
+type DictionaryMedia = {
+  [dictionary: string]: {
+    [path: string]: MediaObject;
+  };
+};
+type NoteData = Record<string, unknown>;
+type Requirement = {
+  type: 'audio';
+} | {
+  type: 'screenshot';
+} | {
+  type: 'clipboardImage';
+} | {
+  type: 'clipboardText';
+} | {
+  type: 'popupSelectionText';
+} | {
+  type: 'textFurigana';
+  text: string;
+  readingMode: TextFuriganaReadingMode | null;
+} | {
+  type: 'dictionaryMedia';
+  dictionary: string;
+  path: string;
+};
+type CreateNoteDetails = {
+  dictionaryEntry: DictionaryEntry;
+  cardFormat: AnkiCardFormat;
+  context: Context;
+  template: string;
+  tags?: string[];
+  requirements?: Requirement[];
+  duplicateScope?: string;
+  duplicateScopeCheckAllModels?: boolean;
+  resultOutputMode?: ResultOutputMode;
+  glossaryLayoutMode?: GlossaryLayoutMode;
+  compactTags?: boolean;
+  mediaOptions?: MediaOptions | null;
+  dictionaryStylesMap?: Map<string, string>;
+};
+type MediaOptions = {
+  audio?: {
+    sources: {
+      type: string;
+      url: string;
+      voice: string;
+    }[];
+    preferredAudioIndex: number | null;
+    idleTimeout: number | null;
+    languageSummary: unknown;
+    enableDefaultAudioSources: boolean;
+  };
+  screenshot?: {
+    format: string;
+    quality: number;
+    contentOrigin: {
+      tabId: number;
+      frameId: number;
+    };
+  };
+  textParsing?: {
+    optionsContext: unknown;
+    scanLength: number;
+  };
+};
+type CreateNoteResult = {
+  note: Note;
+  errors: Error[];
+  requirements: Requirement[];
+};
+type InjectAnkiNoteMediaDefinitionDetails = {
+  type: 'kanji';
+  character: string;
+} | {
+  type: 'term';
+  term: string;
+  reading: string;
+};
+/**
+ * Minimal API interface needed by AnkiNoteBuilder for media injection.
+ */
+interface MinimalApi {
+  injectAnkiNoteMedia(timestamp: number, dictionaryEntryDetails: InjectAnkiNoteMediaDefinitionDetails, audioDetails: unknown, screenshotDetails: unknown, clipboardDetails: {
+    image: boolean;
+    text: boolean;
+  }, dictionaryMediaDetails: {
+    dictionary: string;
+    path: string;
+  }[]): Promise<{
+    audioFileName: string | null;
+    screenshotFileName: string | null;
+    clipboardImageFileName: string | null;
+    clipboardText: string | null;
+    dictionaryMedia: {
+      dictionary: string;
+      path: string;
+      fileName: string | null;
+    }[];
+    errors: SerializedError[];
+  }>;
+  parseText(text: string, optionsContext: unknown, scanLength: number, useInternalParser: boolean, useMecabParser: boolean): Promise<{
+    source: string;
+    content: unknown;
+  }[]>;
+}
+/**
+ * Builds Anki notes from dictionary entries using template rendering.
+ */
+declare class AnkiNoteBuilder {
+  private _api;
+  private _markerPattern;
+  private _templateRenderer;
+  private _batchedRequests;
+  private _batchedRequestsQueued;
+  constructor(templateRenderer: TemplateRenderer, api?: MinimalApi);
+  createNote({
+    dictionaryEntry,
+    cardFormat,
+    context,
+    template,
+    tags,
+    requirements,
+    duplicateScope,
+    duplicateScopeCheckAllModels,
+    resultOutputMode,
+    glossaryLayoutMode,
+    compactTags,
+    mediaOptions,
+    dictionaryStylesMap
+  }: CreateNoteDetails): Promise<CreateNoteResult>;
+  getRenderingData({
+    dictionaryEntry,
+    cardFormat,
+    context,
+    resultOutputMode,
+    glossaryLayoutMode,
+    compactTags,
+    marker,
+    dictionaryStylesMap
+  }: {
+    dictionaryEntry: DictionaryEntry;
+    cardFormat: AnkiCardFormat;
+    context: Context;
+    resultOutputMode?: ResultOutputMode;
+    glossaryLayoutMode?: GlossaryLayoutMode;
+    compactTags?: boolean;
+    marker: string;
+    dictionaryStylesMap: Map<string, string>;
+  }): Promise<NoteData>;
+  getDictionaryEntryDetailsForNote(dictionaryEntry: DictionaryEntry): InjectAnkiNoteMediaDefinitionDetails;
+  private _createData;
+  private _formatField;
+  private _stringReplaceAsync;
+  private _getBatchedTemplateGroup;
+  private _renderTemplateBatched;
+  private _runBatchedRequestsDelayed;
+  private _runBatchedRequests;
+  private _resolveBatchedRequests;
+  private _injectMedia;
+  private _deserializeError;
+} //#endregion
+//#region src/anki/anki-note-data-creator.d.ts
+
+//# sourceMappingURL=anki-note-builder.d.ts.map
+type NoteData$1 = {
+  marker: string;
+  definition: AnkiDictionaryEntry;
+  glossaryLayoutMode: GlossaryLayoutMode;
+  compactTags: boolean;
+  group: boolean;
+  merge: boolean;
+  compactGlossaries: boolean;
+  uniqueExpressions: string[];
+  uniqueReadings: string[];
+  pitches: PitchGroup[];
+  pitchCount: number;
+  phoneticTranscriptions: TranscriptionGroup[];
+  context: PublicContext;
+  media: Media;
+  dictionaryEntry: DictionaryEntry;
+};
+type PublicContext = {
+  query: string;
+  fullQuery: string;
+  document: {
+    title: string;
+  };
+};
+type AnkiDictionaryEntry = AnkiTermDictionaryEntry | AnkiKanjiDictionaryEntry | Record<string, never>;
+type TermDictionaryEntryType = 'term' | 'termGrouped' | 'termMerged';
+type Tag$1 = {
+  name: string;
+  category: string;
+  notes: string;
+  order: number;
+  score: number;
+  dictionary: string;
+  redundant: boolean;
+};
+type PitchTag = {
+  name: string;
+  category: string;
+  order: number;
+  score: number;
+  content: string[];
+  dictionaries: string[];
+  redundant: boolean;
+};
+type Pitch = {
+  expressions: string[];
+  reading: string;
+  positions: number | string;
+  nasalPositions: number[];
+  devoicePositions: number[];
+  tags: PitchTag[];
+  exclusiveExpressions: string[];
+  exclusiveReadings: string[];
+};
+type PitchGroup = {
+  dictionary: string;
+  pitches: Pitch[];
+};
+type Transcription = {
+  expressions: string[];
+  reading: string;
+  ipa: string;
+  tags: Tag[];
+  exclusiveExpressions: string[];
+  exclusiveReadings: string[];
+};
+type TranscriptionGroup = {
+  dictionary: string;
+  phoneticTranscriptions: Transcription[];
+};
+type FuriganaSegment = {
+  text: string;
+  furigana: string;
+};
+type Cloze = {
+  sentence: string;
+  prefix: string;
+  body: string;
+  bodyKana: string;
+  suffix: string;
+};
+type FrequencyNumber = {
+  dictionary: string;
+  frequency: number;
+};
+type TermFrequencyEntry = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  hasReading: boolean;
+  frequency: number | string;
+};
+type TermPitchAccent = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  pitches: {
+    positions: number | string;
+    tags: Tag$1[];
+  }[];
+};
+type TermPhoneticTranscription = {
+  index: number;
+  expressionIndex: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  expression: string;
+  reading: string;
+  phoneticTranscriptions: {
+    ipa: string;
+    tags: Tag$1[];
+  }[];
+};
+type TermHeadword = {
+  sourceTerm: string;
+  expression: string;
+  reading: string;
+  termTags: Tag$1[];
+  frequencies: TermFrequencyEntry[];
+  pitches: TermPitchAccent[];
+  furiganaSegments: FuriganaSegment[];
+  termFrequency: 'popular' | 'rare' | 'normal';
+  wordClasses: string[];
+};
+type TermDefinition = {
+  sequence: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  glossaryScopedStyles: string;
+  dictScopedStyles: string;
+  glossary: TermGlossaryContent[];
+  definitionTags: Tag$1[];
+  only?: string[];
+};
+type KanjiStat = {
+  name: string;
+  category: string;
+  notes: string;
+  order: number;
+  score: number;
+  dictionary: string;
+  value: number | string;
+};
+type KanjiStatGroups = {
+  [key: string]: KanjiStat[];
+};
+type KanjiFrequencyEntry = {
+  index: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  character: string;
+  frequency: number | string;
+};
+type AnkiTermDictionaryEntry = {
+  type: TermDictionaryEntryType;
+  id?: number;
+  source: string | null;
+  rawSource: string | null;
+  sourceTerm?: string | null;
+  inflectionRuleChainCandidates: InflectionRuleChainCandidate[];
+  score: number;
+  isPrimary?: boolean;
+  sequence: number;
+  dictionary: string;
+  dictionaryAlias: string;
+  dictionaryOrder: {
+    index: number;
+  };
+  dictionaryNames: string[];
+  expression: string | string[];
+  reading: string | string[];
+  expressions: TermHeadword[];
+  glossary?: TermGlossaryContent[];
+  glossaryScopedStyles?: string;
+  dictScopedStyles?: string;
+  definitionTags?: Tag$1[];
+  termTags?: Tag$1[];
+  definitions?: TermDefinition[];
+  frequencies: TermFrequencyEntry[];
+  frequencyNumbers: FrequencyNumber[];
+  frequencyHarmonic: number;
+  frequencyAverage: number;
+  pitches: TermPitchAccent[];
+  phoneticTranscriptions: TermPhoneticTranscription[];
+  sourceTermExactMatchCount: number;
+  url: string;
+  cloze: Cloze;
+  furiganaSegments?: FuriganaSegment[];
+};
+type AnkiKanjiDictionaryEntry = {
+  type: 'kanji';
+  character: string;
+  dictionary: string;
+  dictionaryAlias: string;
+  onyomi: string[];
+  kunyomi: string[];
+  glossary: string[];
+  tags: Tag$1[];
+  stats: KanjiStatGroups;
+  frequencies: KanjiFrequencyEntry[];
+  frequencyHarmonic: number;
+  frequencyAverage: number;
+  url: string;
+  cloze: Cloze;
+};
+type CachedValue<T> = {
+  getter: () => T;
+  hasValue: boolean;
+  value: T | undefined;
+};
+declare function createCachedValue<T>(getter: () => T): CachedValue<T>;
+declare function getCachedValue<T>(item: CachedValue<T>): T;
+/**
+ * Creates a compatibility representation of the specified data for Anki template rendering.
+ */
+declare function createAnkiNoteData(marker: string, details: CommonData): NoteData$1;
+declare function getFrequencyHarmonic(dictionaryEntry: TermDictionaryEntry | KanjiDictionaryEntry, headwordIndex: number | null): number;
+
+//#endregion
+//#region src/anki/anki-template-renderer.d.ts
+type HelperOptions = {
+  fn?: (context: unknown) => string;
+  inverse?: (context: unknown) => string;
+  hash: SerializableObject;
+  data: {
+    root: NoteData$1;
+  };
+};
+type HelperFunction<T = unknown> = (args: unknown[], context: unknown, options: HelperOptions) => T;
+type DataType = {
+  modifier: (data: CompositeRenderData) => NoteData$1;
+  composeData: (data: PartialRenderData, commonData: CommonData) => CompositeRenderData;
+};
+type PartialRenderData = {
+  marker: string;
+  commonData?: CommonData;
+};
+type CompositeRenderData = {
+  marker: string;
+  commonData: CommonData;
+};
+type RenderResult$1 = {
+  result: string;
+  requirements: Requirement[];
+};
+type RenderMultiItem$1 = {
+  template: string;
+  templateItems: RenderMultiTemplateItem[];
+};
+type RenderMultiTemplateItem = {
+  type: string;
+  commonData: CommonData;
+  datas: PartialRenderData[];
+};
+type RenderMultiResponse$1 = {
+  result?: RenderResult$1;
+  error?: {
+    name?: string;
+    message?: string;
+    stack?: string;
+    data?: unknown;
+  };
+};
+/**
+ * Interface for a Handlebars-compatible template engine.
+ * Consumers should provide an implementation that wraps their Handlebars instance.
+ */
+interface HandlebarsInstance {
+  compileAST(template: string): (data: NoteData$1) => string;
+  registerHelper(name: string, helper: (...args: unknown[]) => unknown): void;
+  SafeString: new (value: string) => unknown;
+  Utils: {
+    escapeExpression(value: string): string;
+  };
+}
+declare class TemplateRendererCore {
+  private _cache;
+  private _cacheMaxSize;
+  private _dataTypes;
+  private _renderSetup;
+  private _renderCleanup;
+  private _handlebars;
+  constructor(handlebars: HandlebarsInstance);
+  registerHelpers(helpers: [string, HelperFunction][]): void;
+  registerDataType(name: string, details: DataType): void;
+  setRenderCallbacks(setup: ((data: NoteData$1) => {
+    requirements: Requirement[];
+  }) | null, cleanup: ((data: NoteData$1) => void) | null): void;
+  render(template: string, data: PartialRenderData, type: string): RenderResult$1;
+  renderMulti(items: RenderMultiItem$1[]): RenderMultiResponse$1[];
+  getModifiedData(data: CompositeRenderData, type: string): NoteData$1;
+  private _getTemplateInstance;
+  private _renderTemplate;
+  private _getModifiedData;
+  private _updateCacheSize;
+  private _registerHelper;
+}
+/**
+ * This class contains all Anki-specific template rendering functionality.
+ * It registers all 25+ Handlebars helpers and provides template rendering.
+ *
+ * Requires a Handlebars-compatible engine to be injected via the constructor.
+ */
+declare class AnkiTemplateRenderer {
+  private _templateRenderer;
+  private _mediaProvider;
+  private _stateStack;
+  private _requirements;
+  private _cleanupCallbacks;
+  private _handlebars;
+  constructor(handlebars: HandlebarsInstance);
+  /**
+   * Gets the core TemplateRenderer instance.
+   */
+  get templateRenderer(): TemplateRendererCore;
+  /**
+   * Prepares the renderer by registering all Handlebars helpers and data types.
+   */
+  prepare(): Promise<void>;
+  /**
+   * Renders a single template with given data.
+   */
+  render(template: string, data: PartialRenderData, type: string): RenderResult$1;
+  /**
+   * Renders multiple templates with given data.
+   */
+  renderMulti(items: RenderMultiItem$1[]): RenderMultiResponse$1[];
+  /**
+   * Gets modified data for a given type.
+   */
+  getModifiedData(data: CompositeRenderData, type: string): NoteData$1;
+  private _onRenderSetup;
+  private _onRenderCleanup;
+  private _safeString;
+  private _dumpObject;
+  private _furigana;
+  private _furiganaPlain;
+  private _getFuriganaExpressionAndReading;
+  private _stringToMultiLineHtml;
+  private _multiLine;
+  private _regexReplace;
+  private _regexMatch;
+  private _mergeTags;
+  private _eachUpTo;
+  private _spread;
+  private _op;
+  private _evaluateUnaryExpression;
+  private _evaluateBinaryExpression;
+  private _evaluateTernaryExpression;
+  private _get;
+  private _set;
+  private _scope;
+  private _property;
+  private _noop;
+  private _isMoraPitchHigh;
+  private _getKanaMorae;
+  private _getTypeof;
+  private _join;
+  private _concat;
+  private _pitchCategories;
+  private _formatGlossary;
+  private _hasMedia;
+  private _getMedia;
+  private _hiragana;
+  private _katakana;
+  private _getNoteDataFromOptions;
+  private _asString;
+  private _computeValue;
+  private _computeValueString;
+  private _computeInverse;
+  private _computeInverseString;
+}
+
+//#endregion
+export { AnkiCardFormat, AnkiConnect, AnkiDictionaryEntry, FuriganaSegment as AnkiFuriganaSegment, AnkiKanjiDictionaryEntry, KanjiStat as AnkiKanjiStat, KanjiStatGroups as AnkiKanjiStatGroups, AnkiNoteBuilder, NoteData as AnkiNoteBuilderNoteData, Tag$1 as AnkiTag, NoteData$1 as AnkiTemplateNoteData, AnkiTemplateRenderer, TermDefinition as AnkiTermDefinition, AnkiTermDictionaryEntry, TermHeadword as AnkiTermHeadword, Cloze, CommonData, CompositeRenderData, Context, CreateNoteDetails, CreateNoteResult, DataType, DictionaryMedia, FrequencyNumber, GlossaryLayoutMode, HandlebarsInstance, HelperFunction, HelperOptions, InjectAnkiNoteMediaDefinitionDetails, KanjiFrequencyEntry, Media, MediaObject, MediaOptions, MinimalApi, PartialRenderData, Pitch, PitchGroup, PitchTag, PublicContext, RenderMultiItem, RenderMultiResponse, RenderResult, Requirement, ResultOutputMode, SerializedError, RenderMultiItem$1 as TemplateRenderMultiItem, RenderMultiResponse$1 as TemplateRenderMultiResponse, RenderResult$1 as TemplateRenderResult, TemplateRenderer, TermDictionaryEntryType, TermFrequencyEntry, TermPhoneticTranscription, TermPitchAccent, TextFuriganaReadingMode, TextFuriganaSegment, Transcription, TranscriptionGroup, createAnkiNoteData, createCachedValue, getCachedValue, getFrequencyHarmonic };
+//# sourceMappingURL=anki.d.cts.map