yomitan-core 0.1.0

package/dist/dictionary-importer-Cen1z6co.js

@@ -0,0 +1,1821 @@
+import { stringReverse } from "./utilities-bi3EF-q5.js";
+import { YomitanError, toError } from "./errors-DuuDSO5N.js";
+import { compareRevisions } from "./dictionary-data-util-CfOLfEDE.js";
+import { parseJson } from "./json-DGd-cunA.js";
+import { NoOpMediaLoader } from "./media-loader-qRti-Q6h.js";
+import { BlobWriter, TextWriter, Uint8ArrayReader, ZipReader } from "@zip.js/zip.js";
+import Ajv from "ajv";
+
+//#region src/util/media-util.ts
+/**
+* Gets the file extension of a file path.
+*/
+function getFileNameExtension(path) {
+	const match = /\.[^./\\]*$/.exec(path);
+	return match !== null ? match[0] : "";
+}
+/**
+* Gets an image file's media type using a file path.
+*/
+function getImageMediaTypeFromFileName(path) {
+	switch (getFileNameExtension(path).toLowerCase()) {
+		case ".apng": return "image/apng";
+		case ".avif": return "image/avif";
+		case ".bmp": return "image/bmp";
+		case ".gif": return "image/gif";
+		case ".ico":
+		case ".cur": return "image/x-icon";
+		case ".jpg":
+		case ".jpeg":
+		case ".jfif":
+		case ".pjpeg":
+		case ".pjp": return "image/jpeg";
+		case ".png": return "image/png";
+		case ".svg": return "image/svg+xml";
+		case ".tif":
+		case ".tiff": return "image/tiff";
+		case ".webp": return "image/webp";
+		default: return null;
+	}
+}
+/**
+* Gets the file extension for a corresponding image media type.
+*/
+function getFileExtensionFromImageMediaType(mediaType) {
+	switch (mediaType) {
+		case "image/apng": return ".apng";
+		case "image/avif": return ".avif";
+		case "image/bmp": return ".bmp";
+		case "image/gif": return ".gif";
+		case "image/x-icon": return ".ico";
+		case "image/jpeg": return ".jpeg";
+		case "image/png": return ".png";
+		case "image/svg+xml": return ".svg";
+		case "image/tiff": return ".tiff";
+		case "image/webp": return ".webp";
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/import/schemas/dictionary-index-schema.json
+var $id$7 = "dictionaryIndex";
+var $schema$7 = "http://json-schema.org/draft-07/schema#";
+var definitions$3 = { "isoLanguageCode": {
+	"type": "string",
+	"description": "ISO language code (ISO 639-1 where possible, ISO 639-3 otherwise).",
+	"pattern": "^[a-z]{2,3}$"
+} };
+var type$7 = "object";
+var description$7 = "Index file containing information about the data contained in the dictionary.";
+var required = ["title", "revision"];
+var properties = {
+	"title": {
+		"type": "string",
+		"description": "Title of the dictionary."
+	},
+	"revision": {
+		"type": "string",
+		"description": "Revision of the dictionary. This value is displayed, and used to check for dictionary updates."
+	},
+	"minimumYomitanVersion": {
+		"type": "string",
+		"description": "Minimum version of Yomitan that is compatible with this dictionary."
+	},
+	"sequenced": {
+		"type": "boolean",
+		"default": false,
+		"description": "Whether or not this dictionary contains sequencing information for related terms."
+	},
+	"format": {
+		"type": "integer",
+		"description": "Format of data found in the JSON data files.",
+		"enum": [
+			1,
+			2,
+			3
+		]
+	},
+	"version": {
+		"type": "integer",
+		"description": "Alias for format.",
+		"enum": [
+			1,
+			2,
+			3
+		]
+	},
+	"author": {
+		"type": "string",
+		"description": "Creator of the dictionary."
+	},
+	"isUpdatable": {
+		"type": "boolean",
+		"const": true,
+		"description": "Whether this dictionary contains links to its latest version."
+	},
+	"indexUrl": {
+		"type": "string",
+		"description": "URL for the index file of the latest revision of the dictionary, used to check for updates."
+	},
+	"downloadUrl": {
+		"type": "string",
+		"description": "URL for the download of the latest revision of the dictionary."
+	},
+	"url": {
+		"type": "string",
+		"description": "URL for the source of the dictionary, displayed in the dictionary details."
+	},
+	"description": {
+		"type": "string",
+		"description": "Description of the dictionary data."
+	},
+	"attribution": {
+		"type": "string",
+		"description": "Attribution information for the dictionary data."
+	},
+	"sourceLanguage": {
+		"$ref": "#/definitions/isoLanguageCode",
+		"description": "Language of the terms in the dictionary."
+	},
+	"targetLanguage": {
+		"$ref": "#/definitions/isoLanguageCode",
+		"description": "Main language of the definitions in the dictionary."
+	},
+	"frequencyMode": {
+		"type": "string",
+		"enum": ["occurrence-based", "rank-based"]
+	},
+	"tagMeta": {
+		"type": "object",
+		"description": "Tag information for terms and kanji. This object is obsolete and individual tag files should be used instead.",
+		"additionalProperties": {
+			"type": "object",
+			"description": "Information about a single tag. The object key is the name of the tag.",
+			"properties": {
+				"category": {
+					"type": "string",
+					"description": "Category for the tag."
+				},
+				"order": {
+					"type": "number",
+					"description": "Sorting order for the tag."
+				},
+				"notes": {
+					"type": "string",
+					"description": "Notes for the tag."
+				},
+				"score": {
+					"type": "number",
+					"description": "Score used to determine popularity. Negative values are more rare and positive values are more frequent. This score is also used to sort search results."
+				}
+			},
+			"additionalProperties": false
+		}
+	}
+};
+var anyOf = [{ "required": ["format"] }, { "required": ["version"] }];
+var dependencies = { "isUpdatable": ["indexUrl", "downloadUrl"] };
+var dictionary_index_schema_default = {
+	$id: $id$7,
+	$schema: $schema$7,
+	definitions: definitions$3,
+	type: type$7,
+	description: description$7,
+	required,
+	properties,
+	anyOf,
+	dependencies
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-kanji-bank-v1-schema.json
+var $id$6 = "dictionaryKanjiBankV1";
+var $schema$6 = "http://json-schema.org/draft-07/schema#";
+var type$6 = "array";
+var description$6 = "Data file containing kanji information.";
+var items$6 = {
+	"type": "array",
+	"description": "Information about a single kanji character.",
+	"minItems": 4,
+	"maxItems": 4,
+	"items": [
+		{
+			"type": "string",
+			"description": "Kanji character.",
+			"minLength": 1
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated onyomi readings for the kanji character. An empty string is treated as no readings."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated kunyomi readings for the kanji character. An empty string is treated as no readings."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated tags for the kanji character. An empty string is treated as no tags."
+		}
+	],
+	"additionalItems": {
+		"type": "string",
+		"description": "A meaning for the kanji character."
+	}
+};
+var dictionary_kanji_bank_v1_schema_default = {
+	$id: $id$6,
+	$schema: $schema$6,
+	type: type$6,
+	description: description$6,
+	items: items$6
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-kanji-bank-v3-schema.json
+var $id$5 = "dictionaryKanjiBankV3";
+var $schema$5 = "http://json-schema.org/draft-07/schema#";
+var type$5 = "array";
+var description$5 = "Data file containing kanji information.";
+var items$5 = {
+	"type": "array",
+	"description": "Information about a single kanji character.",
+	"minItems": 6,
+	"maxItems": 6,
+	"additionalItems": false,
+	"items": [
+		{
+			"type": "string",
+			"description": "Kanji character.",
+			"minLength": 1
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated onyomi readings for the kanji character. An empty string is treated as no readings."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated kunyomi readings for the kanji character. An empty string is treated as no readings."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated tags for the kanji character. An empty string is treated as no tags."
+		},
+		{
+			"type": "array",
+			"description": "Array of meanings for the kanji character.",
+			"items": {
+				"type": "string",
+				"description": "A meaning for the kanji character."
+			}
+		},
+		{
+			"type": "object",
+			"description": "Various stats for the kanji character.",
+			"additionalProperties": { "type": "string" }
+		}
+	]
+};
+var dictionary_kanji_bank_v3_schema_default = {
+	$id: $id$5,
+	$schema: $schema$5,
+	type: type$5,
+	description: description$5,
+	items: items$5
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-kanji-meta-bank-v3-schema.json
+var $id$4 = "dictionaryKanjiMetaBankV3";
+var $schema$4 = "http://json-schema.org/draft-07/schema#";
+var definitions$2 = { "frequency": { "oneOf": [{ "type": ["string", "number"] }, {
+	"type": "object",
+	"additionalProperties": false,
+	"required": ["value"],
+	"properties": {
+		"value": { "type": "number" },
+		"displayValue": { "type": "string" }
+	}
+}] } };
+var type$4 = "array";
+var description$4 = "Custom metadata for kanji characters.";
+var items$4 = {
+	"type": "array",
+	"description": "Metadata about a single kanji character.",
+	"minItems": 3,
+	"maxItems": 3,
+	"additionalItems": false,
+	"items": [
+		{
+			"type": "string",
+			"minLength": 1
+		},
+		{
+			"type": "string",
+			"const": "freq",
+			"description": "Type of data. \"freq\" corresponds to frequency information."
+		},
+		{
+			"$ref": "#/definitions/frequency",
+			"description": "Data for the character."
+		}
+	]
+};
+var dictionary_kanji_meta_bank_v3_schema_default = {
+	$id: $id$4,
+	$schema: $schema$4,
+	definitions: definitions$2,
+	type: type$4,
+	description: description$4,
+	items: items$4
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-tag-bank-v3-schema.json
+var $id$3 = "dictionaryTagBankV3";
+var $schema$3 = "http://json-schema.org/draft-07/schema#";
+var type$3 = "array";
+var description$3 = "Data file containing tag information for terms and kanji.";
+var items$3 = {
+	"type": "array",
+	"description": "Information about a single tag.",
+	"minItems": 5,
+	"maxItems": 5,
+	"additionalItems": false,
+	"items": [
+		{
+			"type": "string",
+			"description": "Tag name."
+		},
+		{
+			"type": "string",
+			"description": "Category for the tag."
+		},
+		{
+			"type": "number",
+			"description": "Sorting order for the tag."
+		},
+		{
+			"type": "string",
+			"description": "Notes for the tag."
+		},
+		{
+			"type": "number",
+			"description": "Score used to determine popularity. Negative values are more rare and positive values are more frequent. This score is also used to sort search results."
+		}
+	]
+};
+var dictionary_tag_bank_v3_schema_default = {
+	$id: $id$3,
+	$schema: $schema$3,
+	type: type$3,
+	description: description$3,
+	items: items$3
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-term-bank-v1-schema.json
+var $id$2 = "dictionaryTermBankV1";
+var $schema$2 = "http://json-schema.org/draft-07/schema#";
+var type$2 = "array";
+var description$2 = "Data file containing term information.";
+var items$2 = {
+	"type": "array",
+	"description": "Information about a single term.",
+	"minItems": 5,
+	"maxItems": 5,
+	"items": [
+		{
+			"type": "string",
+			"description": "The text for the term."
+		},
+		{
+			"type": "string",
+			"description": "Reading of the term, or an empty string if the reading is the same as the term."
+		},
+		{
+			"type": ["string", "null"],
+			"description": "String of space-separated tags for the definition. An empty string is treated as no tags."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated rule identifiers for the definition which is used to validate delinflection. Valid rule identifiers are: v1: ichidan verb; v5: godan verb; vs: suru verb; vz: zuru verb; vk: kuru verb; adj-i: i-adjective. An empty string corresponds to words which aren't inflected, such as nouns."
+		},
+		{
+			"type": "number",
+			"description": "Score used to determine popularity. Negative values are more rare and positive values are more frequent. This score is also used to sort search results."
+		}
+	],
+	"additionalItems": {
+		"type": "string",
+		"description": "Single definition for the term."
+	}
+};
+var dictionary_term_bank_v1_schema_default = {
+	$id: $id$2,
+	$schema: $schema$2,
+	type: type$2,
+	description: description$2,
+	items: items$2
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-term-bank-v3-schema.json
+var $id$1 = "dictionaryTermBankV3";
+var $schema$1 = "http://json-schema.org/draft-07/schema#";
+var definitions$1 = {
+	"structuredContent": { "oneOf": [
+		{
+			"type": "string",
+			"description": "Represents a text node."
+		},
+		{
+			"type": "array",
+			"items": {
+				"$ref": "#/definitions/structuredContent",
+				"description": "An array of child content."
+			}
+		},
+		{
+			"type": "object",
+			"oneOf": [
+				{
+					"type": "object",
+					"description": "Empty tags.",
+					"required": ["tag"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"const": "br"
+						},
+						"data": { "$ref": "#/definitions/structuredContentData" }
+					}
+				},
+				{
+					"type": "object",
+					"description": "Generic container tags.",
+					"required": ["tag"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"enum": [
+								"ruby",
+								"rt",
+								"rp",
+								"table",
+								"thead",
+								"tbody",
+								"tfoot",
+								"tr"
+							]
+						},
+						"content": { "$ref": "#/definitions/structuredContent" },
+						"data": { "$ref": "#/definitions/structuredContentData" },
+						"lang": {
+							"type": "string",
+							"description": "Defines the language of an element in the format defined by RFC 5646."
+						}
+					}
+				},
+				{
+					"type": "object",
+					"description": "Table tags.",
+					"required": ["tag"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"enum": ["td", "th"]
+						},
+						"content": { "$ref": "#/definitions/structuredContent" },
+						"data": { "$ref": "#/definitions/structuredContentData" },
+						"colSpan": {
+							"type": "integer",
+							"minimum": 1
+						},
+						"rowSpan": {
+							"type": "integer",
+							"minimum": 1
+						},
+						"style": { "$ref": "#/definitions/structuredContentStyle" },
+						"lang": {
+							"type": "string",
+							"description": "Defines the language of an element in the format defined by RFC 5646."
+						}
+					}
+				},
+				{
+					"type": "object",
+					"description": "Container tags supporting configurable styles.",
+					"required": ["tag"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"enum": [
+								"span",
+								"div",
+								"ol",
+								"ul",
+								"li",
+								"details",
+								"summary"
+							]
+						},
+						"content": { "$ref": "#/definitions/structuredContent" },
+						"data": { "$ref": "#/definitions/structuredContentData" },
+						"style": { "$ref": "#/definitions/structuredContentStyle" },
+						"title": {
+							"type": "string",
+							"description": "Hover text for the element."
+						},
+						"open": {
+							"type": "boolean",
+							"description": "Whether or not the details element is open by default."
+						},
+						"lang": {
+							"type": "string",
+							"description": "Defines the language of an element in the format defined by RFC 5646."
+						}
+					}
+				},
+				{
+					"type": "object",
+					"description": "Image tag.",
+					"required": ["tag", "path"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"const": "img"
+						},
+						"data": { "$ref": "#/definitions/structuredContentData" },
+						"path": {
+							"type": "string",
+							"description": "Path to the image file in the archive."
+						},
+						"width": {
+							"type": "number",
+							"description": "Preferred width of the image.",
+							"minimum": 0
+						},
+						"height": {
+							"type": "number",
+							"description": "Preferred height of the image.",
+							"minimum": 0
+						},
+						"title": {
+							"type": "string",
+							"description": "Hover text for the image."
+						},
+						"alt": {
+							"type": "string",
+							"description": "Alt text for the image."
+						},
+						"description": {
+							"type": "string",
+							"description": "Description of the image."
+						},
+						"pixelated": {
+							"type": "boolean",
+							"description": "Whether or not the image should appear pixelated at sizes larger than the image's native resolution.",
+							"default": false
+						},
+						"imageRendering": {
+							"type": "string",
+							"description": "Controls how the image is rendered. The value of this field supersedes the pixelated field.",
+							"enum": [
+								"auto",
+								"pixelated",
+								"crisp-edges"
+							],
+							"default": "auto"
+						},
+						"appearance": {
+							"type": "string",
+							"description": "Controls the appearance of the image. The \"monochrome\" value will mask the opaque parts of the image using the current text color.",
+							"enum": ["auto", "monochrome"],
+							"default": "auto"
+						},
+						"background": {
+							"type": "boolean",
+							"description": "Whether or not a background color is displayed behind the image.",
+							"default": true
+						},
+						"collapsed": {
+							"type": "boolean",
+							"description": "Whether or not the image is collapsed by default.",
+							"default": false
+						},
+						"collapsible": {
+							"type": "boolean",
+							"description": "Whether or not the image can be collapsed.",
+							"default": false
+						},
+						"verticalAlign": {
+							"type": "string",
+							"description": "The vertical alignment of the image.",
+							"enum": [
+								"baseline",
+								"sub",
+								"super",
+								"text-top",
+								"text-bottom",
+								"middle",
+								"top",
+								"bottom"
+							]
+						},
+						"border": {
+							"type": "string",
+							"description": "Shorthand for border width, style, and color."
+						},
+						"borderRadius": {
+							"type": "string",
+							"description": "Roundness of the corners of the image's outer border edge."
+						},
+						"sizeUnits": {
+							"type": "string",
+							"description": "The units for the width and height.",
+							"enum": ["px", "em"]
+						}
+					}
+				},
+				{
+					"type": "object",
+					"description": "Link tag.",
+					"required": ["tag", "href"],
+					"additionalProperties": false,
+					"properties": {
+						"tag": {
+							"type": "string",
+							"const": "a"
+						},
+						"content": { "$ref": "#/definitions/structuredContent" },
+						"href": {
+							"type": "string",
+							"description": "The URL for the link. URLs starting with a ? are treated as internal links to other dictionary content.",
+							"pattern": "^(?:https?:|\\?)[\\w\\W]*"
+						},
+						"lang": {
+							"type": "string",
+							"description": "Defines the language of an element in the format defined by RFC 5646."
+						}
+					}
+				}
+			]
+		}
+	] },
+	"structuredContentData": {
+		"type": "object",
+		"description": "Generic data attributes that should be added to the element.",
+		"additionalProperties": { "type": "string" }
+	},
+	"structuredContentStyle": {
+		"type": "object",
+		"additionalProperties": false,
+		"properties": {
+			"fontStyle": {
+				"type": "string",
+				"enum": ["normal", "italic"],
+				"default": "normal"
+			},
+			"fontWeight": {
+				"type": "string",
+				"enum": ["normal", "bold"],
+				"default": "normal"
+			},
+			"fontSize": {
+				"type": "string",
+				"default": "medium"
+			},
+			"color": { "type": "string" },
+			"background": { "type": "string" },
+			"backgroundColor": { "type": "string" },
+			"textDecorationLine": { "oneOf": [{
+				"type": "string",
+				"enum": [
+					"none",
+					"underline",
+					"overline",
+					"line-through"
+				],
+				"default": "none"
+			}, {
+				"type": "array",
+				"items": {
+					"type": "string",
+					"enum": [
+						"underline",
+						"overline",
+						"line-through"
+					],
+					"default": "none"
+				}
+			}] },
+			"textDecorationStyle": {
+				"type": "string",
+				"enum": [
+					"solid",
+					"double",
+					"dotted",
+					"dashed",
+					"wavy"
+				],
+				"default": "solid"
+			},
+			"textDecorationColor": { "type": "string" },
+			"borderColor": { "type": "string" },
+			"borderStyle": { "type": "string" },
+			"borderRadius": { "type": "string" },
+			"borderWidth": { "type": "string" },
+			"clipPath": { "type": "string" },
+			"verticalAlign": {
+				"type": "string",
+				"enum": [
+					"baseline",
+					"sub",
+					"super",
+					"text-top",
+					"text-bottom",
+					"middle",
+					"top",
+					"bottom"
+				],
+				"default": "baseline"
+			},
+			"textAlign": {
+				"type": "string",
+				"enum": [
+					"start",
+					"end",
+					"left",
+					"right",
+					"center",
+					"justify",
+					"justify-all",
+					"match-parent"
+				],
+				"default": "start"
+			},
+			"textEmphasis": { "type": "string" },
+			"textShadow": { "type": "string" },
+			"margin": { "type": "string" },
+			"marginTop": {
+				"type": ["number", "string"],
+				"default": 0
+			},
+			"marginLeft": {
+				"type": ["number", "string"],
+				"default": 0
+			},
+			"marginRight": {
+				"type": ["number", "string"],
+				"default": 0
+			},
+			"marginBottom": {
+				"type": ["number", "string"],
+				"default": 0
+			},
+			"padding": { "type": "string" },
+			"paddingTop": { "type": "string" },
+			"paddingLeft": { "type": "string" },
+			"paddingRight": { "type": "string" },
+			"paddingBottom": { "type": "string" },
+			"wordBreak": {
+				"type": "string",
+				"enum": [
+					"normal",
+					"break-all",
+					"keep-all"
+				],
+				"default": "normal"
+			},
+			"whiteSpace": {
+				"type": "string",
+				"default": "normal"
+			},
+			"cursor": {
+				"type": "string",
+				"default": "auto"
+			},
+			"listStyleType": {
+				"type": "string",
+				"default": "disc"
+			}
+		}
+	}
+};
+var type$1 = "array";
+var description$1 = "Data file containing term information.";
+var items$1 = {
+	"type": "array",
+	"description": "Information about a single term.",
+	"minItems": 8,
+	"maxItems": 8,
+	"additionalItems": false,
+	"items": [
+		{
+			"type": "string",
+			"description": "The text for the term."
+		},
+		{
+			"type": "string",
+			"description": "Reading of the term, or an empty string if the reading is the same as the term."
+		},
+		{
+			"type": ["string", "null"],
+			"description": "String of space-separated tags for the definition. An empty string is treated as no tags."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated rule identifiers for the definition which is used to validate deinflection. An empty string should be used for words which aren't inflected."
+		},
+		{
+			"type": "number",
+			"description": "Score used to determine popularity. Negative values are more rare and positive values are more frequent. This score is also used to sort search results."
+		},
+		{
+			"type": "array",
+			"description": "Array of definitions for the term.",
+			"items": { "oneOf": [
+				{
+					"type": "string",
+					"description": "Single definition for the term."
+				},
+				{
+					"type": "object",
+					"description": "Single detailed definition for the term.",
+					"required": ["type"],
+					"properties": { "type": {
+						"type": "string",
+						"description": "The type of the data for this definition.",
+						"enum": [
+							"text",
+							"image",
+							"structured-content"
+						]
+					} },
+					"oneOf": [
+						{
+							"required": ["type", "text"],
+							"additionalProperties": false,
+							"properties": {
+								"type": {
+									"type": "string",
+									"const": "text"
+								},
+								"text": {
+									"type": "string",
+									"description": "Single definition for the term."
+								}
+							}
+						},
+						{
+							"required": ["type", "content"],
+							"additionalProperties": false,
+							"properties": {
+								"type": {
+									"type": "string",
+									"const": "structured-content"
+								},
+								"content": {
+									"$ref": "#/definitions/structuredContent",
+									"description": "Single definition for the term using a structured content object."
+								}
+							}
+						},
+						{
+							"required": ["type", "path"],
+							"additionalProperties": false,
+							"properties": {
+								"type": {
+									"type": "string",
+									"const": "image"
+								},
+								"path": {
+									"type": "string",
+									"description": "Path to the image file in the archive."
+								},
+								"width": {
+									"type": "integer",
+									"description": "Preferred width of the image.",
+									"minimum": 1
+								},
+								"height": {
+									"type": "integer",
+									"description": "Preferred height of the image.",
+									"minimum": 1
+								},
+								"title": {
+									"type": "string",
+									"description": "Hover text for the image."
+								},
+								"alt": {
+									"type": "string",
+									"description": "Alt text for the image."
+								},
+								"description": {
+									"type": "string",
+									"description": "Description of the image."
+								},
+								"pixelated": {
+									"type": "boolean",
+									"description": "Whether or not the image should appear pixelated at sizes larger than the image's native resolution.",
+									"default": false
+								},
+								"imageRendering": {
+									"type": "string",
+									"description": "Controls how the image is rendered. The value of this field supersedes the pixelated field.",
+									"enum": [
+										"auto",
+										"pixelated",
+										"crisp-edges"
+									],
+									"default": "auto"
+								},
+								"appearance": {
+									"type": "string",
+									"description": "Controls the appearance of the image. The \"monochrome\" value will mask the opaque parts of the image using the current text color.",
+									"enum": ["auto", "monochrome"],
+									"default": "auto"
+								},
+								"background": {
+									"type": "boolean",
+									"description": "Whether or not a background color is displayed behind the image.",
+									"default": true
+								},
+								"collapsed": {
+									"type": "boolean",
+									"description": "Whether or not the image is collapsed by default.",
+									"default": false
+								},
+								"collapsible": {
+									"type": "boolean",
+									"description": "Whether or not the image can be collapsed.",
+									"default": true
+								}
+							}
+						}
+					]
+				},
+				{
+					"type": "array",
+					"description": "Deinflection of the term to an uninflected term.",
+					"minItems": 2,
+					"maxItems": 2,
+					"items": [{
+						"type": "string",
+						"description": "The uninflected term."
+					}, {
+						"type": "array",
+						"description": "A chain of inflection rules that produced the inflected term",
+						"items": {
+							"type": "string",
+							"description": "A single inflection rule."
+						}
+					}]
+				}
+			] }
+		},
+		{
+			"type": "integer",
+			"description": "Sequence number for the term. Terms with the same sequence number can be shown together when the \"resultOutputMode\" option is set to \"merge\"."
+		},
+		{
+			"type": "string",
+			"description": "String of space-separated tags for the term. An empty string is treated as no tags."
+		}
+	]
+};
+var dictionary_term_bank_v3_schema_default = {
+	$id: $id$1,
+	$schema: $schema$1,
+	definitions: definitions$1,
+	type: type$1,
+	description: description$1,
+	items: items$1
+};
+
+//#endregion
+//#region src/import/schemas/dictionary-term-meta-bank-v3-schema.json
+var $id = "dictionaryTermMetaBankV3";
+var $schema = "http://json-schema.org/draft-07/schema#";
+var definitions = { "frequency": { "oneOf": [{ "type": ["string", "number"] }, {
+	"type": "object",
+	"additionalProperties": false,
+	"required": ["value"],
+	"properties": {
+		"value": { "type": "number" },
+		"displayValue": { "type": "string" }
+	}
+}] } };
+var type = "array";
+var description = "Custom metadata for terms.";
+var items = {
+	"type": "array",
+	"description": "Metadata about a single term.",
+	"minItems": 3,
+	"maxItems": 3,
+	"additionalItems": false,
+	"items": [
+		{
+			"type": "string",
+			"description": "The text for the term."
+		},
+		{
+			"type": "string",
+			"enum": [
+				"freq",
+				"pitch",
+				"ipa"
+			],
+			"description": "Type of data. \"freq\" corresponds to frequency information; \"pitch\" corresponds to pitch information. \"ipa\" corresponds to IPA transcription."
+		},
+		{ "description": "Data for the term." }
+	],
+	"oneOf": [
+		{
+			"minItems": 3,
+			"maxItems": 3,
+			"items": [
+				{},
+				{ "const": "freq" },
+				{ "oneOf": [{
+					"$ref": "#/definitions/frequency",
+					"description": "Frequency information for the term."
+				}, {
+					"type": "object",
+					"required": ["reading", "frequency"],
+					"additionalProperties": false,
+					"properties": {
+						"reading": {
+							"type": "string",
+							"description": "Reading for the term."
+						},
+						"frequency": {
+							"$ref": "#/definitions/frequency",
+							"description": "Frequency information for the term."
+						}
+					}
+				}] }
+			]
+		},
+		{
+			"minItems": 3,
+			"maxItems": 3,
+			"items": [
+				{},
+				{ "const": "pitch" },
+				{
+					"type": "object",
+					"description": "Pitch accent information for the term.",
+					"required": ["reading", "pitches"],
+					"additionalProperties": false,
+					"properties": {
+						"reading": {
+							"type": "string",
+							"description": "Reading for the term."
+						},
+						"pitches": {
+							"type": "array",
+							"description": "List of different pitch accent information for the term and reading combination.",
+							"items": {
+								"type": "object",
+								"required": ["position"],
+								"additionalProperties": false,
+								"properties": {
+									"position": { "oneOf": [{
+										"type": "integer",
+										"description": "Mora position of the pitch accent downstep. A value of 0 indicates that the word does not have a downstep (heiban).",
+										"minimum": 0
+									}, {
+										"type": "string",
+										"description": "Pitch level of each mora with H representing high and L representing low. For example: HHLL for a 4 mora word.",
+										"pattern": "^[HL]+$"
+									}] },
+									"nasal": { "oneOf": [{
+										"type": "integer",
+										"description": "Position of a mora with nasal sound.",
+										"minimum": 0
+									}, {
+										"type": "array",
+										"description": "Positions of morae with nasal sound.",
+										"items": {
+											"type": "integer",
+											"minimum": 0
+										}
+									}] },
+									"devoice": { "oneOf": [{
+										"type": "integer",
+										"description": "Position of a mora with devoiced sound.",
+										"minimum": 0
+									}, {
+										"type": "array",
+										"description": "Positions of morae with devoiced sound.",
+										"items": {
+											"type": "integer",
+											"minimum": 0
+										}
+									}] },
+									"tags": {
+										"type": "array",
+										"description": "List of tags for this pitch accent.",
+										"items": {
+											"type": "string",
+											"description": "Tag for this pitch accent. This typically corresponds to a certain type of part of speech."
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			]
+		},
+		{
+			"minItems": 3,
+			"maxItems": 3,
+			"items": [
+				{},
+				{ "const": "ipa" },
+				{
+					"type": ["object"],
+					"description": "IPA transcription information for the term.",
+					"required": ["reading", "transcriptions"],
+					"additionalProperties": false,
+					"properties": {
+						"reading": {
+							"type": "string",
+							"description": "Reading for the term."
+						},
+						"transcriptions": {
+							"type": "array",
+							"description": "List of different IPA transcription information for the term and reading combination.",
+							"items": {
+								"type": "object",
+								"required": ["ipa"],
+								"additionalProperties": false,
+								"properties": {
+									"ipa": {
+										"type": "string",
+										"description": "IPA transcription for the term."
+									},
+									"tags": {
+										"type": "array",
+										"description": "List of tags for this IPA transcription.",
+										"items": {
+											"type": "string",
+											"description": "Tag for this IPA transcription."
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			]
+		}
+	]
+};
+var dictionary_term_meta_bank_v3_schema_default = {
+	$id,
+	$schema,
+	definitions,
+	type,
+	description,
+	items
+};
+
+//#endregion
+//#region src/import/schema-validators.ts
+let _validators = null;
+/**
+* Returns compiled AJV schema validators for all dictionary data bank types.
+* Validators are compiled once on first call and cached for subsequent calls.
+*/
+function getSchemaValidators() {
+	if (_validators !== null) return _validators;
+	const ajv = new Ajv({ allowUnionTypes: true });
+	_validators = {
+		dictionaryIndex: ajv.compile(dictionary_index_schema_default),
+		dictionaryTermBankV1: ajv.compile(dictionary_term_bank_v1_schema_default),
+		dictionaryTermBankV3: ajv.compile(dictionary_term_bank_v3_schema_default),
+		dictionaryTermMetaBankV3: ajv.compile(dictionary_term_meta_bank_v3_schema_default),
+		dictionaryKanjiBankV1: ajv.compile(dictionary_kanji_bank_v1_schema_default),
+		dictionaryKanjiBankV3: ajv.compile(dictionary_kanji_bank_v3_schema_default),
+		dictionaryKanjiMetaBankV3: ajv.compile(dictionary_kanji_meta_bank_v3_schema_default),
+		dictionaryTagBankV3: ajv.compile(dictionary_tag_bank_v3_schema_default)
+	};
+	return _validators;
+}
+
+//#endregion
+//#region src/import/dictionary-importer.ts
+const INDEX_FILE_NAME = "index.json";
+var DictionaryImporterClass = class {
+	_mediaLoader;
+	_onProgress;
+	_progressData;
+	constructor(mediaLoader, onProgress) {
+		this._mediaLoader = mediaLoader ?? new NoOpMediaLoader();
+		this._onProgress = typeof onProgress === "function" ? onProgress : () => {};
+		this._progressData = this._createProgressData();
+	}
+	async importDictionary(dictionaryDatabase, archiveContent, details) {
+		if (!dictionaryDatabase) throw new Error("Invalid database");
+		if (!dictionaryDatabase.isOpen) throw new Error("Database is not ready");
+		const errors = [];
+		const maxTransactionLength = 1e3;
+		const bulkAddProgressAllowance = 1e3;
+		const bulkAdd = async (objectStoreName, entries) => {
+			const entryCount = entries.length;
+			let progressIndexIncrease = bulkAddProgressAllowance / Math.ceil(entryCount / maxTransactionLength);
+			if (entryCount < maxTransactionLength) progressIndexIncrease = bulkAddProgressAllowance;
+			if (entryCount === 0) this._progressData.index += progressIndexIncrease;
+			for (let i = 0; i < entryCount; i += maxTransactionLength) {
+				const count = Math.min(maxTransactionLength, entryCount - i);
+				try {
+					await dictionaryDatabase.bulkAdd(objectStoreName, entries, i, count);
+				} catch (e) {
+					errors.push(toError(e));
+				}
+				this._progressData.index += progressIndexIncrease;
+				this._progress();
+			}
+		};
+		this._progressReset();
+		const fileMap = await this._getFilesFromArchive(archiveContent);
+		const index = await this._readAndValidateIndex(fileMap);
+		const dictionaryTitle = index.title;
+		const version = typeof index.format === "number" ? index.format : index.version;
+		if (await dictionaryDatabase.dictionaryExists(dictionaryTitle)) return {
+			errors: [new Error(`Dictionary ${dictionaryTitle} is already imported, skipped it.`)],
+			result: null
+		};
+		this._progressNextStep(0);
+		const dataBankSchemas = this._getDataBankSchemas(version);
+		const queryDetails = [
+			["termFiles", /^term_bank_(\d+)\.json$/],
+			["termMetaFiles", /^term_meta_bank_(\d+)\.json$/],
+			["kanjiFiles", /^kanji_bank_(\d+)\.json$/],
+			["kanjiMetaFiles", /^kanji_meta_bank_(\d+)\.json$/],
+			["tagFiles", /^tag_bank_(\d+)\.json$/]
+		];
+		const archiveFiles = Object.fromEntries(this._getArchiveFiles(fileMap, queryDetails));
+		const termFiles = archiveFiles.termFiles;
+		const termMetaFiles = archiveFiles.termMetaFiles;
+		const kanjiFiles = archiveFiles.kanjiFiles;
+		const kanjiMetaFiles = archiveFiles.kanjiMetaFiles;
+		const tagFiles = archiveFiles.tagFiles;
+		const prefixWildcardsSupported = !!details.prefixWildcardsSupported;
+		this._progressNextStep(termFiles.length + termMetaFiles.length + kanjiFiles.length + kanjiMetaFiles.length + tagFiles.length);
+		for (const termFile of termFiles) await this._validateFile(termFile, dataBankSchemas[0]);
+		for (const termMetaFile of termMetaFiles) await this._validateFile(termMetaFile, dataBankSchemas[1]);
+		for (const kanjiFile of kanjiFiles) await this._validateFile(kanjiFile, dataBankSchemas[2]);
+		for (const kanjiMetaFile of kanjiMetaFiles) await this._validateFile(kanjiMetaFile, dataBankSchemas[3]);
+		for (const tagFile of tagFiles) await this._validateFile(tagFile, dataBankSchemas[4]);
+		this._progressNextStep((termFiles.length * 2 + termMetaFiles.length + kanjiFiles.length + kanjiMetaFiles.length + tagFiles.length) * bulkAddProgressAllowance);
+		let importSuccess = false;
+		const counts = {
+			terms: { total: 0 },
+			termMeta: { total: 0 },
+			kanji: { total: 0 },
+			kanjiMeta: { total: 0 },
+			tagMeta: { total: 0 },
+			media: { total: 0 }
+		};
+		const yomitanVersion = details.yomitanVersion;
+		let summaryDetails = {
+			prefixWildcardsSupported,
+			counts,
+			styles: "",
+			yomitanVersion,
+			importSuccess
+		};
+		let summary = this._createSummary(dictionaryTitle, version, index, summaryDetails);
+		const primaryKey = await dictionaryDatabase.addWithResult("dictionaries", summary);
+		try {
+			const uniqueMediaPaths = new Set();
+			for (const termFile of termFiles) {
+				const requirements = [];
+				let termList = await (version === 1 ? this._readFileSequence([termFile], this._convertTermBankEntryV1.bind(this), dictionaryTitle) : this._readFileSequence([termFile], this._convertTermBankEntryV3.bind(this), dictionaryTitle));
+				if (prefixWildcardsSupported) for (const entry of termList) {
+					entry.expressionReverse = stringReverse(entry.expression);
+					entry.readingReverse = stringReverse(entry.reading);
+				}
+				for (let i = 0, ii = termList.length; i < ii; ++i) {
+					const entry = termList[i];
+					const glossaryList = entry.glossary;
+					for (let j = 0, jj = glossaryList.length; j < jj; ++j) {
+						const glossary = glossaryList[j];
+						if (typeof glossary !== "object" || glossary === null || Array.isArray(glossary)) continue;
+						glossaryList[j] = this._formatDictionaryTermGlossaryObject(glossary, entry, requirements);
+					}
+				}
+				const alreadyAddedRequirements = requirements.filter((x) => {
+					return uniqueMediaPaths.has(x.source.path);
+				});
+				const notAddedRequirements = requirements.filter((x) => {
+					return !uniqueMediaPaths.has(x.source.path);
+				});
+				for (const requirement of requirements) uniqueMediaPaths.add(requirement.source.path);
+				await this._resolveAsyncRequirements(alreadyAddedRequirements, fileMap);
+				let { media } = await this._resolveAsyncRequirements(notAddedRequirements, fileMap);
+				await bulkAdd("media", media);
+				counts.media.total += media.length;
+				this._progress();
+				await bulkAdd("terms", termList);
+				counts.terms.total += termList.length;
+				this._progress();
+				termList = [];
+				media = [];
+			}
+			for (const termMetaFile of termMetaFiles) {
+				let termMetaList = await this._readFileSequence([termMetaFile], this._convertTermMetaBankEntry.bind(this), dictionaryTitle);
+				await bulkAdd("termMeta", termMetaList);
+				for (const [key, value] of Object.entries(this._getMetaCounts(termMetaList))) if (key in counts.termMeta) counts.termMeta[key] += value;
+				else counts.termMeta[key] = value;
+				this._progress();
+				termMetaList = [];
+			}
+			for (const kanjiFile of kanjiFiles) {
+				let kanjiList = await (version === 1 ? this._readFileSequence([kanjiFile], this._convertKanjiBankEntryV1.bind(this), dictionaryTitle) : this._readFileSequence([kanjiFile], this._convertKanjiBankEntryV3.bind(this), dictionaryTitle));
+				await bulkAdd("kanji", kanjiList);
+				counts.kanji.total += kanjiList.length;
+				this._progress();
+				kanjiList = [];
+			}
+			for (const kanjiMetaFile of kanjiMetaFiles) {
+				let kanjiMetaList = await this._readFileSequence([kanjiMetaFile], this._convertKanjiMetaBankEntry.bind(this), dictionaryTitle);
+				await bulkAdd("kanjiMeta", kanjiMetaList);
+				for (const [key, value] of Object.entries(this._getMetaCounts(kanjiMetaList))) if (key in counts.kanjiMeta) counts.kanjiMeta[key] += value;
+				else counts.kanjiMeta[key] = value;
+				this._progress();
+				kanjiMetaList = [];
+			}
+			for (const tagFile of tagFiles) {
+				let tagList = await this._readFileSequence([tagFile], this._convertTagBankEntry.bind(this), dictionaryTitle);
+				this._addOldIndexTags(index, tagList, dictionaryTitle);
+				await bulkAdd("tagMeta", tagList);
+				counts.tagMeta.total += tagList.length;
+				this._progress();
+				tagList = [];
+			}
+			importSuccess = true;
+		} catch (e) {
+			errors.push(toError(e));
+		}
+		this._progressNextStep(0);
+		const stylesFileName = "styles.css";
+		const stylesFile = fileMap.get(stylesFileName);
+		let styles = "";
+		if (typeof stylesFile !== "undefined") {
+			styles = await this._getData(stylesFile, new TextWriter());
+			const cssErrors = this._validateCss(styles);
+			if (cssErrors.length > 0) return {
+				errors: cssErrors,
+				result: null
+			};
+		}
+		summaryDetails = {
+			prefixWildcardsSupported,
+			counts,
+			styles,
+			yomitanVersion,
+			importSuccess
+		};
+		summary = this._createSummary(dictionaryTitle, version, index, summaryDetails);
+		await dictionaryDatabase.bulkUpdate("dictionaries", [{
+			data: summary,
+			primaryKey
+		}], 0, 1);
+		this._progress();
+		return {
+			result: summary,
+			errors
+		};
+	}
+	async _getFilesFromArchive(archiveContent) {
+		const zipFileReader = new Uint8ArrayReader(new Uint8Array(archiveContent));
+		const zipReader = new ZipReader(zipFileReader, { useWebWorkers: false });
+		const zipEntries = await zipReader.getEntries();
+		const fileMap = new Map();
+		for (const entry of zipEntries) fileMap.set(entry.filename, entry);
+		return fileMap;
+	}
+	_findRedundantDirectories(fileMap) {
+		let indexPath = "";
+		for (const file of fileMap) if (file[0].replace(/.*\//, "") === INDEX_FILE_NAME) indexPath = file[0];
+		const redundantDirectoriesRegex = new RegExp(`.*(?=${INDEX_FILE_NAME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`);
+		const redundantDirectories = indexPath.match(redundantDirectoriesRegex);
+		return redundantDirectories ? redundantDirectories[0] : null;
+	}
+	async _readAndValidateIndex(fileMap) {
+		const indexFile = fileMap.get(INDEX_FILE_NAME);
+		if (typeof indexFile === "undefined") {
+			const redundantDirectories = this._findRedundantDirectories(fileMap);
+			if (redundantDirectories) throw new Error(`Dictionary index found nested in redundant directories: "${redundantDirectories}" when it must be in the archive\'s root directory`);
+			throw new Error("No dictionary index found in archive");
+		}
+		const indexContent = await this._getData(indexFile, new TextWriter());
+		const index = parseJson(indexContent);
+		const ajvSchemas = getSchemaValidators();
+		if (!ajvSchemas.dictionaryIndex(index)) throw this._formatAjvSchemaError(ajvSchemas.dictionaryIndex, INDEX_FILE_NAME);
+		const validIndex = index;
+		const version = typeof validIndex.format === "number" ? validIndex.format : validIndex.version;
+		validIndex.version = version;
+		const { title, revision } = validIndex;
+		if (typeof version !== "number" || !title || !revision) throw new Error("Unrecognized dictionary format");
+		return validIndex;
+	}
+	_createProgressData() {
+		return {
+			index: 0,
+			count: 0
+		};
+	}
+	_progressReset() {
+		this._progressData = this._createProgressData();
+		this._progress(true);
+	}
+	_progressNextStep(count) {
+		this._progressData.index = 0;
+		this._progressData.count = count;
+		this._progress(true);
+	}
+	_progress(nextStep = false) {
+		this._onProgress({
+			...this._progressData,
+			nextStep
+		});
+	}
+	_createSummary(dictionaryTitle, version, index, details) {
+		const indexSequenced = index.sequenced;
+		const { prefixWildcardsSupported, counts, styles, importSuccess } = details;
+		const summary = {
+			title: dictionaryTitle,
+			revision: index.revision,
+			sequenced: typeof indexSequenced === "boolean" && indexSequenced,
+			version,
+			importDate: Date.now(),
+			prefixWildcardsSupported,
+			counts,
+			styles,
+			importSuccess
+		};
+		const { minimumYomitanVersion, author, url, description: description$8, attribution, frequencyMode, isUpdatable, sourceLanguage, targetLanguage } = index;
+		if (typeof minimumYomitanVersion === "string") {
+			if (details.yomitanVersion === "0.0.0.0") {} else if (compareRevisions(details.yomitanVersion, minimumYomitanVersion)) throw new Error(`Dictionary is incompatible with this version of Yomitan (${details.yomitanVersion}; minimum required: ${minimumYomitanVersion})`);
+			summary.minimumYomitanVersion = minimumYomitanVersion;
+		}
+		if (typeof author === "string") summary.author = author;
+		if (typeof url === "string") summary.url = url;
+		if (typeof description$8 === "string") summary.description = description$8;
+		if (typeof attribution === "string") summary.attribution = attribution;
+		if (typeof frequencyMode === "string") summary.frequencyMode = frequencyMode;
+		if (typeof sourceLanguage === "string") summary.sourceLanguage = sourceLanguage;
+		if (typeof targetLanguage === "string") summary.targetLanguage = targetLanguage;
+		if (typeof isUpdatable === "boolean") {
+			const { indexUrl, downloadUrl } = index;
+			if (!isUpdatable || !this._validateUrl(indexUrl) || !this._validateUrl(downloadUrl)) throw new Error("Invalid index data for updatable dictionary");
+			summary.isUpdatable = isUpdatable;
+			summary.indexUrl = indexUrl;
+			summary.downloadUrl = downloadUrl;
+		}
+		return summary;
+	}
+	_validateUrl(string) {
+		if (typeof string !== "string") return false;
+		let url;
+		try {
+			url = new URL(string);
+		} catch (_) {
+			return false;
+		}
+		return url.protocol === "http:" || url.protocol === "https:";
+	}
+	_formatAjvSchemaError(schema, fileName) {
+		const e = new YomitanError(`Dictionary has invalid data in '${fileName}' '${JSON.stringify(schema.errors)}'`);
+		e.data = schema.errors;
+		return e;
+	}
+	_getDataBankSchemas(version) {
+		const termBank = version === 1 ? "dictionaryTermBankV1" : "dictionaryTermBankV3";
+		const termMetaBank = "dictionaryTermMetaBankV3";
+		const kanjiBank = version === 1 ? "dictionaryKanjiBankV1" : "dictionaryKanjiBankV3";
+		const kanjiMetaBank = "dictionaryKanjiMetaBankV3";
+		const tagBank = "dictionaryTagBankV3";
+		return [
+			termBank,
+			termMetaBank,
+			kanjiBank,
+			kanjiMetaBank,
+			tagBank
+		];
+	}
+	_validateCss(css) {
+		return css ? [] : [new Error("No styles found")];
+	}
+	_formatDictionaryTermGlossaryObject(data, entry, requirements) {
+		switch (data.type) {
+			case "text": return data.text;
+			case "image": return this._formatDictionaryTermGlossaryImage(data, entry, requirements);
+			case "structured-content": return this._formatStructuredContent(data, entry, requirements);
+			default: throw new Error(`Unhandled data type: ${data.type}`);
+		}
+	}
+	_formatDictionaryTermGlossaryImage(data, entry, requirements) {
+		const target = {
+			type: "image",
+			path: ""
+		};
+		requirements.push({
+			type: "image",
+			target,
+			source: data,
+			entry
+		});
+		return target;
+	}
+	_formatStructuredContent(data, entry, requirements) {
+		const content = this._prepareStructuredContent(data.content, entry, requirements);
+		return {
+			type: "structured-content",
+			content
+		};
+	}
+	_prepareStructuredContent(content, entry, requirements) {
+		if (typeof content === "string" || !(typeof content === "object" && content !== null)) return content;
+		if (Array.isArray(content)) {
+			for (let i = 0, ii = content.length; i < ii; ++i) content[i] = this._prepareStructuredContent(content[i], entry, requirements);
+			return content;
+		}
+		const { tag } = content;
+		switch (tag) {
+			case "img": return this._prepareStructuredContentImage(content, entry, requirements);
+		}
+		const childContent = content.content;
+		if (typeof childContent !== "undefined") content.content = this._prepareStructuredContent(childContent, entry, requirements);
+		return content;
+	}
+	_prepareStructuredContentImage(content, entry, requirements) {
+		const target = {
+			tag: "img",
+			path: ""
+		};
+		requirements.push({
+			type: "structured-content-image",
+			target,
+			source: content,
+			entry
+		});
+		return target;
+	}
+	async _resolveAsyncRequirements(requirements, fileMap) {
+		const media = new Map();
+		const context = {
+			fileMap,
+			media
+		};
+		for (const requirement of requirements) await this._resolveAsyncRequirement(context, requirement);
+		return { media: [...media.values()] };
+	}
+	async _resolveAsyncRequirement(context, requirement) {
+		switch (requirement.type) {
+			case "image":
+				await this._resolveDictionaryTermGlossaryImage(context, requirement.target, requirement.source, requirement.entry);
+				break;
+			case "structured-content-image":
+				await this._resolveStructuredContentImage(context, requirement.target, requirement.source, requirement.entry);
+				break;
+			default: return;
+		}
+	}
+	async _resolveDictionaryTermGlossaryImage(context, target, source, entry) {
+		await this._createImageData(context, target, source, entry);
+	}
+	async _resolveStructuredContentImage(context, target, source, entry) {
+		const { verticalAlign, border, borderRadius, sizeUnits } = source;
+		await this._createImageData(context, target, source, entry);
+		if (typeof verticalAlign === "string") target.verticalAlign = verticalAlign;
+		if (typeof border === "string") target.border = border;
+		if (typeof borderRadius === "string") target.borderRadius = borderRadius;
+		if (typeof sizeUnits === "string") target.sizeUnits = sizeUnits;
+	}
+	async _createImageData(context, target, source, entry) {
+		const { path, width: preferredWidth, height: preferredHeight, title, alt, description: description$8, pixelated, imageRendering, appearance, background, collapsed, collapsible } = source;
+		const { width, height } = await this._getImageMedia(context, path, entry);
+		target.path = path;
+		target.width = width;
+		target.height = height;
+		if (typeof preferredWidth === "number") target.preferredWidth = preferredWidth;
+		if (typeof preferredHeight === "number") target.preferredHeight = preferredHeight;
+		if (typeof title === "string") target.title = title;
+		if (typeof alt === "string") target.alt = alt;
+		if (typeof description$8 === "string") target.description = description$8;
+		if (typeof pixelated === "boolean") target.pixelated = pixelated;
+		if (typeof imageRendering === "string") target.imageRendering = imageRendering;
+		if (typeof appearance === "string") target.appearance = appearance;
+		if (typeof background === "boolean") target.background = background;
+		if (typeof collapsed === "boolean") target.collapsed = collapsed;
+		if (typeof collapsible === "boolean") target.collapsible = collapsible;
+	}
+	async _getImageMedia(context, path, entry) {
+		const { media } = context;
+		const { dictionary } = entry;
+		const createError = (message) => {
+			const { expression, reading } = entry;
+			const readingSource = reading.length > 0 ? ` (${reading})` : "";
+			return new Error(`${message} at path ${JSON.stringify(path)} for ${expression}${readingSource} in ${dictionary}`);
+		};
+		let mediaData = media.get(path);
+		if (typeof mediaData !== "undefined") {
+			if (getFileExtensionFromImageMediaType(mediaData.mediaType) === null) throw createError("Media file is not a valid image");
+			return mediaData;
+		}
+		const file = context.fileMap.get(path);
+		if (typeof file === "undefined") throw createError("Could not find image");
+		let content = await (await this._getData(file, new BlobWriter())).arrayBuffer();
+		const mediaType = getImageMediaTypeFromFileName(path);
+		if (mediaType === null) throw createError("Could not determine media type for image");
+		let width;
+		let height;
+		try {
+			({content, width, height} = await this._mediaLoader.getImageDetails(content, mediaType));
+		} catch (e) {
+			throw createError("Could not load image");
+		}
+		mediaData = {
+			dictionary,
+			path,
+			mediaType,
+			width,
+			height,
+			content
+		};
+		media.set(path, mediaData);
+		return mediaData;
+	}
+	_convertTermBankEntryV1(entry, dictionary) {
+		let [expression, reading, definitionTags, rules, score, ...glossary] = entry;
+		reading = reading.length > 0 ? reading : expression;
+		return {
+			expression,
+			reading,
+			definitionTags,
+			rules,
+			score,
+			glossary,
+			dictionary
+		};
+	}
+	_convertTermBankEntryV3(entry, dictionary) {
+		let [expression, reading, definitionTags, rules, score, glossary, sequence, termTags] = entry;
+		reading = reading.length > 0 ? reading : expression;
+		return {
+			expression,
+			reading,
+			definitionTags,
+			rules,
+			score,
+			glossary,
+			sequence,
+			termTags,
+			dictionary
+		};
+	}
+	_convertTermMetaBankEntry(entry, dictionary) {
+		const [expression, mode, data] = entry;
+		return {
+			expression,
+			mode,
+			data,
+			dictionary
+		};
+	}
+	_convertKanjiBankEntryV1(entry, dictionary) {
+		const [character, onyomi, kunyomi, tags, ...meanings] = entry;
+		return {
+			character,
+			onyomi,
+			kunyomi,
+			tags,
+			meanings,
+			dictionary
+		};
+	}
+	_convertKanjiBankEntryV3(entry, dictionary) {
+		const [character, onyomi, kunyomi, tags, meanings, stats] = entry;
+		return {
+			character,
+			onyomi,
+			kunyomi,
+			tags,
+			meanings,
+			stats,
+			dictionary
+		};
+	}
+	_convertKanjiMetaBankEntry(entry, dictionary) {
+		const [character, mode, data] = entry;
+		return {
+			character,
+			mode,
+			data,
+			dictionary
+		};
+	}
+	_convertTagBankEntry(entry, dictionary) {
+		const [name, category, order, notes, score] = entry;
+		return {
+			name,
+			category,
+			order,
+			notes,
+			score,
+			dictionary
+		};
+	}
+	_addOldIndexTags(index, results, dictionary) {
+		const { tagMeta } = index;
+		if (typeof tagMeta !== "object" || tagMeta === null) return;
+		for (const [name, value] of Object.entries(tagMeta)) {
+			const { category, order, notes, score } = value;
+			results.push({
+				name,
+				category,
+				order,
+				notes,
+				score,
+				dictionary
+			});
+		}
+	}
+	_getArchiveFiles(fileMap, queryDetails) {
+		const results = new Map();
+		for (const [fileType] of queryDetails) results.set(fileType, []);
+		for (const [fileName, fileEntry] of fileMap.entries()) for (const [fileType, fileNameFormat] of queryDetails) {
+			if (!fileNameFormat.test(fileName)) continue;
+			const entries = results.get(fileType);
+			if (typeof entries !== "undefined") {
+				entries.push(fileEntry);
+				break;
+			}
+		}
+		return results;
+	}
+	async _readFileSequence(files, convertEntry, dictionaryTitle) {
+		const results = [];
+		for (const file of files) {
+			const content = await this._getData(file, new TextWriter());
+			let entries;
+			try {
+				entries = parseJson(content);
+			} catch (error) {
+				if (error instanceof Error) throw new Error(`${error.message} in '${file.filename}'`);
+			}
+			if (Array.isArray(entries)) for (const entry of entries) results.push(convertEntry(entry, dictionaryTitle));
+		}
+		return results;
+	}
+	async _validateFile(file, schemaName) {
+		const content = await this._getData(file, new TextWriter());
+		let entries;
+		try {
+			entries = parseJson(content);
+		} catch (error) {
+			if (error instanceof Error) throw new Error(`${error.message} in '${file.filename}'`);
+		}
+		const ajvSchemas = getSchemaValidators();
+		const schema = ajvSchemas[schemaName];
+		if (!schema(entries)) throw this._formatAjvSchemaError(schema, file.filename);
+		++this._progressData.index;
+		this._progress();
+		return true;
+	}
+	_getMetaCounts(metaList) {
+		const countsMap = new Map();
+		for (const { mode } of metaList) {
+			let count = countsMap.get(mode);
+			count = typeof count !== "undefined" ? count + 1 : 1;
+			countsMap.set(mode, count);
+		}
+		const counts = { total: metaList.length };
+		for (const [key, value] of countsMap.entries()) {
+			if (Object.prototype.hasOwnProperty.call(counts, key)) continue;
+			counts[key] = value;
+		}
+		return counts;
+	}
+	async _getData(entry, writer) {
+		if (typeof entry.getData === "undefined") throw new Error(`Cannot read ${entry.filename}`);
+		return await entry.getData(writer);
+	}
+};
+
+//#endregion
+export { DictionaryImporterClass, getSchemaValidators };
+//# sourceMappingURL=dictionary-importer-Cen1z6co.js.map