private static EpubSpine ReadSpine(XElement spineNode, EpubVersion epubVersion)
{
EpubSpine result = new EpubSpine();
foreach (XAttribute spineNodeAttribute in spineNode.Attributes())
{
string attributeValue = spineNodeAttribute.Value;
switch (spineNodeAttribute.GetLowerCaseLocalName())
{
case "id":
result.Id = attributeValue;
break;
case "page-progression-direction":
result.PageProgressionDirection = PageProgressionDirectionParser.Parse(attributeValue);
break;
case "toc":
result.Toc = attributeValue;
break;
}
}
if (epubVersion == EpubVersion.EPUB_2 && String.IsNullOrWhiteSpace(result.Toc))
{
throw new Exception("Incorrect EPUB spine: TOC is missing");
}
foreach (XElement spineItemNode in spineNode.Elements())
{
if (spineItemNode.CompareNameTo("itemref"))
{
EpubSpineItemRef spineItemRef = new EpubSpineItemRef();
foreach (XAttribute spineItemNodeAttribute in spineItemNode.Attributes())
{
string attributeValue = spineItemNodeAttribute.Value;
switch (spineItemNodeAttribute.GetLowerCaseLocalName())
{
case "id":
spineItemRef.Id = attributeValue;
break;
case "idref":
spineItemRef.IdRef = attributeValue;
break;
case "properties":
spineItemRef.Properties = SpinePropertyParser.ParsePropertyList(attributeValue);
break;
}
}
if (String.IsNullOrWhiteSpace(spineItemRef.IdRef))
{
throw new Exception("Incorrect EPUB spine: item ID ref is missing");
}
XAttribute linearAttribute = spineItemNode.Attribute("linear");
spineItemRef.IsLinear = linearAttribute == null || !linearAttribute.CompareValueTo("no");
result.Add(spineItemRef);
}
}
return(result);
}
private EpubFactory(EpubVersion version, string title, CultureInfo culture)
{
string textVersion = System.Enum.GetName(typeof(EpubVersion), version);
_culture = culture;
_version = version;
_title = title;
_type = Type.GetType($"WebToEpubKindle.Core.Domain.Versions.{textVersion}.Epub{textVersion}");
}
private FileEpubFactory(EpubVersion version, Epub epub)
{
_epub = epub;
_version = version;
var textVersion = Enum.GetName(typeof(EpubVersion), _version);
_type = Type.GetType($"WebToEpubKindle.Core.Infrastructure.Versions.{textVersion}.Creator");
_typeHtmlConverter = Type.GetType($"WebToEpubKindle.Core.Domain.Versions.{textVersion}.HtmlConverter{textVersion}");
_typeImageConverter = Type.GetType($"WebToEpubKindle.Core.Domain.Versions.{textVersion}.ImageConverter{textVersion}");
}
public static string GetVersionString(EpubVersion epubVersion)
{
Type epubVersionType = typeof(EpubVersion);
FieldInfo fieldInfo = epubVersionType.GetRuntimeField(epubVersion.ToString());
if (fieldInfo != null)
{
return(fieldInfo.GetCustomAttribute <VersionStringAttribute>().Version);
}
else
{
return(epubVersion.ToString());
}
}
private static XElement WriteMetadata(OpfMetadata metadata, EpubVersion version)
{
var root = new XElement(OpfElements.Metadata);
foreach (var contributor in metadata.Contributors)
{
var element = new XElement(OpfElements.Contributor, contributor.Text);
if (!string.IsNullOrWhiteSpace(contributor.AlternateScript))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.AlternateScript, contributor.AlternateScript));
}
if (!string.IsNullOrWhiteSpace(contributor.FileAs))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.FileAs, contributor.FileAs));
}
if (!string.IsNullOrWhiteSpace(contributor.Role))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.Role, contributor.Role));
}
root.Add(element);
}
foreach (var description in metadata.Descriptions)
{
root.Add(new XElement(OpfElements.Description, description));
}
foreach (var lang in metadata.Languages)
{
root.Add(new XElement(OpfElements.Language, lang));
}
foreach (var title in metadata.Titles)
{
root.Add(new XElement(OpfElements.Title, title));
}
foreach (var creator in metadata.Creators)
{
var element = new XElement(OpfElements.Creator, creator.Text);
if (!string.IsNullOrWhiteSpace(creator.AlternateScript))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.AlternateScript, creator.AlternateScript));
}
if (!string.IsNullOrWhiteSpace(creator.FileAs))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.FileAs, creator.FileAs));
}
if (!string.IsNullOrWhiteSpace(creator.Role))
{
element.Add(new XAttribute(OpfMetadataCreator.Attributes.Role, creator.Role));
}
root.Add(element);
}
foreach (var publisher in metadata.Publishers)
{
root.Add(new XElement(OpfElements.Publisher, publisher));
}
foreach (var subject in metadata.Subjects)
{
root.Add(new XElement(OpfElements.Subject, subject));
}
foreach (var meta in metadata.Metas)
{
var element = new XElement(OpfElements.Meta);
switch (version)
{
case EpubVersion.Epub2:
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Content, meta.Text));
break;
case EpubVersion.Epub3:
element.Add(meta.Text);
break;
default:
throw new NotImplementedException($"Epub version not support: {version} ({nameof(OpfWriter)})");
}
if (!string.IsNullOrWhiteSpace(meta.Id))
{
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Id, meta.Id));
}
if (!string.IsNullOrWhiteSpace(meta.Name))
{
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Name, meta.Name));
}
if (!string.IsNullOrWhiteSpace(meta.Property))
{
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Property, meta.Property));
}
if (!string.IsNullOrWhiteSpace(meta.Refines))
{
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Refines, meta.Refines));
}
if (!string.IsNullOrWhiteSpace(meta.Scheme))
{
element.Add(new XAttribute(OpfMetadataMeta.Attributes.Scheme, meta.Scheme));
}
root.Add(element);
}
foreach (var coverage in metadata.Coverages)
{
root.Add(new XElement(OpfElements.Coverages, coverage));
}
foreach (var date in metadata.Dates)
{
var element = new XElement(OpfElements.Date, date.Text);
if (!string.IsNullOrWhiteSpace(date.Event))
{
element.Add(new XAttribute(OpfMetadataDate.Attributes.Event, date.Event));
}
root.Add(element);
}
foreach (var format in metadata.Formats)
{
root.Add(new XElement(OpfElements.Format, format));
}
foreach (var identifier in metadata.Identifiers)
{
var element = new XElement(OpfElements.Identifier, identifier.Text);
if (!string.IsNullOrWhiteSpace(identifier.Id))
{
element.Add(new XAttribute(OpfMetadataIdentifier.Attributes.Id, identifier.Id));
}
if (!string.IsNullOrWhiteSpace(identifier.Scheme))
{
element.Add(new XAttribute(OpfMetadataIdentifier.Attributes.Scheme, identifier.Scheme));
}
root.Add(element);
}
foreach (var relation in metadata.Relations)
{
root.Add(new XElement(OpfElements.Relation, relation));
}
foreach (var right in metadata.Rights)
{
root.Add(new XElement(OpfElements.Rights, right));
}
foreach (var source in metadata.Sources)
{
root.Add(new XElement(OpfElements.Source, source));
}
foreach (var type in metadata.Types)
{
root.Add(new XElement(OpfElements.Type, type));
}
return(root);
}
private static EpubMetadata ReadMetadata(XmlNode metadataNode, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List <string>();
result.Creators = new List <EpubMetadataCreator>();
result.Subjects = new List <string>();
result.Publishers = new List <string>();
result.Contributors = new List <EpubMetadataContributor>();
result.Dates = new List <EpubMetadataDate>();
result.Types = new List <string>();
result.Formats = new List <string>();
result.Identifiers = new List <EpubMetadataIdentifier>();
result.Sources = new List <string>();
result.Languages = new List <string>();
result.Relations = new List <string>();
result.Coverages = new List <string>();
result.Rights = new List <string>();
result.MetaItems = new List <EpubMetadataMeta>();
foreach (XmlNode metadataItemNode in metadataNode.ChildNodes)
{
string innerText = metadataItemNode.InnerText;
switch (metadataItemNode.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(innerText);
break;
case "creator":
EpubMetadataCreator creator = ReadMetadataCreator(metadataItemNode);
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(innerText);
break;
case "description":
result.Description = innerText;
break;
case "publisher":
result.Publishers.Add(innerText);
break;
case "contributor":
EpubMetadataContributor contributor = ReadMetadataContributor(metadataItemNode);
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = ReadMetadataDate(metadataItemNode);
result.Dates.Add(date);
break;
case "type":
result.Types.Add(innerText);
break;
case "format":
result.Formats.Add(innerText);
break;
case "identifier":
EpubMetadataIdentifier identifier = ReadMetadataIdentifier(metadataItemNode);
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(innerText);
break;
case "language":
result.Languages.Add(innerText);
break;
case "relation":
result.Relations.Add(innerText);
break;
case "coverage":
result.Coverages.Add(innerText);
break;
case "rights":
result.Rights.Add(innerText);
break;
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion2(metadataItemNode);
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion3(metadataItemNode);
result.MetaItems.Add(meta);
}
break;
}
}
return(result);
}
private static async System.Threading.Tasks.Task<EpubMetadata> ReadMetadataAsync(XmlReader reader, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List<string>();
result.Creators = new List<EpubMetadataCreator>();
result.Subjects = new List<string>();
result.Publishers = new List<string>();
result.Contributors = new List<EpubMetadataContributor>();
result.Dates = new List<EpubMetadataDate>();
result.Types = new List<string>();
result.Formats = new List<string>();
result.Identifiers = new List<EpubMetadataIdentifier>();
result.Sources = new List<string>();
result.Languages = new List<string>();
result.Relations = new List<string>();
result.Coverages = new List<string>();
result.Rights = new List<string>();
result.MetaItems = new List<EpubMetadataMeta>();
//Parsing all metadata insides and saving it in EpubMetadata instance
//
//Мне нужно пройтись по всем нодам внутри метадаты последовательно, извлечь ноды указанные в массиве metadataNodesNames...
//... и сохранить их в структуре EpubMetadata
//В каждой итерации нам нужно извлечь имя нода, сделать маленькими буквами и,
// в зависимости от того есть ли он в массиве - выполнить запись в структуру
//ИЛИ мы можем тупо искать по заданным в массиве именам, с опасностью, что какая-то сука написала капсами и это ебнет весь ридер
//
bool isMetadataAvailable = await reader.ReadToFollowingAsync("metadata", "http://www.idpf.org/2007/opf");
if (!isMetadataAvailable)
throw new Exception("EPUB parsing error: metadata not found in the package.");
while (await reader.ReadAsync() && !(reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "metadata"))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(reader.ReadElementContentAsString());
break;
case "creator":
EpubMetadataCreator creator = new EpubMetadataCreator();
creator.Role = reader.GetAttribute("opf:role");
creator.FileAs = reader.GetAttribute("opf:file-as");
creator.Creator = reader.ReadElementContentAsString();
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(reader.ReadElementContentAsString());
break;
case "description":
result.Description = reader.ReadElementContentAsString();
break;
case "publisher":
result.Publishers.Add(reader.ReadElementContentAsString());
break;
case "contributor":
EpubMetadataContributor contributor = new EpubMetadataContributor();
contributor.Role = reader.GetAttribute("opf:role");
contributor.FileAs = reader.GetAttribute("opf:file-as");
contributor.Contributor = reader.ReadElementContentAsString();
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = new EpubMetadataDate();
date.Event = reader.GetAttribute("opf:event");
date.Date = reader.ReadElementContentAsString();
result.Dates.Add(date);
break;
case "type":
result.Types.Add(reader.ReadElementContentAsString());
break;
case "format":
result.Formats.Add(reader.ReadElementContentAsString());
break;
case "identifier":
EpubMetadataIdentifier identifier = new EpubMetadataIdentifier();
identifier.Id = reader.GetAttribute("id");
identifier.Scheme = reader.GetAttribute("opf:scheme");
identifier.Identifier = reader.ReadElementContentAsString();
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(reader.ReadElementContentAsString());
break;
case "language":
result.Languages.Add(reader.ReadElementContentAsString());
break;
case "relation":
result.Relations.Add(reader.ReadElementContentAsString());
break;
case "coverage":
result.Coverages.Add(reader.ReadElementContentAsString());
break;
case "rights":
result.Rights.Add(reader.ReadElementContentAsString());
break;
//looks like there is an optional refining node "meta" and it is present in EPUB3
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Name = reader.GetAttribute("name");
meta.Content = reader.GetAttribute("content");
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Id = reader.GetAttribute("id");
meta.Refines = reader.GetAttribute("refines");
meta.Property = reader.GetAttribute("property");
meta.Scheme = reader.GetAttribute("scheme");
meta.Content = reader.ReadElementContentAsString();
result.MetaItems.Add(meta);
}
break;
}
break;
}
}
return result;
}
private static EpubMetadata ReadMetadata(XElement metadataNode, EpubVersion epubVersion)
{
var result = new EpubMetadata
{
Titles = new List <string>(),
Creators = new List <EpubMetadataCreator>(),
Subjects = new List <string>(),
Publishers = new List <string>(),
Contributors = new List <EpubMetadataContributor>(),
Dates = new List <EpubMetadataDate>(),
Types = new List <string>(),
Formats = new List <string>(),
Identifiers = new List <EpubMetadataIdentifier>(),
Sources = new List <string>(),
Languages = new List <string>(),
Relations = new List <string>(),
Coverages = new List <string>(),
Rights = new List <string>(),
MetaItems = new List <EpubMetadataMeta>()
};
foreach (var metadataItemNode in metadataNode.Elements())
{
var innerText = metadataItemNode.Value;
switch (metadataItemNode.GetLowerCaseLocalName())
{
case "title":
result.Titles.Add(innerText);
break;
case "creator":
var creator = ReadMetadataCreator(metadataItemNode);
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(innerText);
break;
case "description":
result.Description = innerText;
break;
case "publisher":
result.Publishers.Add(innerText);
break;
case "contributor":
var contributor = ReadMetadataContributor(metadataItemNode);
result.Contributors.Add(contributor);
break;
case "date":
var date = ReadMetadataDate(metadataItemNode);
result.Dates.Add(date);
break;
case "type":
result.Types.Add(innerText);
break;
case "format":
result.Formats.Add(innerText);
break;
case "identifier":
var identifier = ReadMetadataIdentifier(metadataItemNode);
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(innerText);
break;
case "language":
result.Languages.Add(innerText);
break;
case "relation":
result.Relations.Add(innerText);
break;
case "coverage":
result.Coverages.Add(innerText);
break;
case "rights":
result.Rights.Add(innerText);
break;
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
var meta = ReadMetadataMetaVersion2(metadataItemNode);
result.MetaItems.Add(meta);
}
else if (epubVersion == EpubVersion.EPUB_3_0 || epubVersion == EpubVersion.EPUB_3_1)
{
var meta = ReadMetadataMetaVersion3(metadataItemNode);
result.MetaItems.Add(meta);
}
break;
}
}
return(result);
}
private static EpubMetadata ReadMetadata(XmlNode metadataNode, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List<string>();
result.Creators = new List<EpubMetadataCreator>();
result.Subjects = new List<string>();
result.Publishers = new List<string>();
result.Contributors = new List<EpubMetadataContributor>();
result.Dates = new List<EpubMetadataDate>();
result.Types = new List<string>();
result.Formats = new List<string>();
result.Identifiers = new List<EpubMetadataIdentifier>();
result.Sources = new List<string>();
result.Languages = new List<string>();
result.Relations = new List<string>();
result.Coverages = new List<string>();
result.Rights = new List<string>();
result.MetaItems = new List<EpubMetadataMeta>();
foreach (XmlNode metadataItemNode in metadataNode.ChildNodes)
{
string innerText = metadataItemNode.InnerText;
switch (metadataItemNode.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(innerText);
break;
case "creator":
EpubMetadataCreator creator = ReadMetadataCreator(metadataItemNode);
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(innerText);
break;
case "description":
result.Description = innerText;
break;
case "publisher":
result.Publishers.Add(innerText);
break;
case "contributor":
EpubMetadataContributor contributor = ReadMetadataContributor(metadataItemNode);
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = ReadMetadataDate(metadataItemNode);
result.Dates.Add(date);
break;
case "type":
result.Types.Add(innerText);
break;
case "format":
result.Formats.Add(innerText);
break;
case "identifier":
EpubMetadataIdentifier identifier = ReadMetadataIdentifier(metadataItemNode);
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(innerText);
break;
case "language":
result.Languages.Add(innerText);
break;
case "relation":
result.Relations.Add(innerText);
break;
case "coverage":
result.Coverages.Add(innerText);
break;
case "rights":
result.Rights.Add(innerText);
break;
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion2(metadataItemNode);
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = ReadMetadataMetaVersion3(metadataItemNode);
result.MetaItems.Add(meta);
}
break;
}
}
return result;
}
public static FileEpubFactory Initialize(EpubVersion version, Epub epub) => new FileEpubFactory(version, epub);
private static async System.Threading.Tasks.Task <EpubMetadata> ReadMetadataAsync(XmlReader reader, EpubVersion epubVersion)
{
EpubMetadata result = new EpubMetadata();
result.Titles = new List <string>();
result.Creators = new List <EpubMetadataCreator>();
result.Subjects = new List <string>();
result.Publishers = new List <string>();
result.Contributors = new List <EpubMetadataContributor>();
result.Dates = new List <EpubMetadataDate>();
result.Types = new List <string>();
result.Formats = new List <string>();
result.Identifiers = new List <EpubMetadataIdentifier>();
result.Sources = new List <string>();
result.Languages = new List <string>();
result.Relations = new List <string>();
result.Coverages = new List <string>();
result.Rights = new List <string>();
result.MetaItems = new List <EpubMetadataMeta>();
//Parsing all metadata insides and saving it in EpubMetadata instance
//
//Мне нужно пройтись по всем нодам внутри метадаты последовательно, извлечь ноды указанные в массиве metadataNodesNames...
//... и сохранить их в структуре EpubMetadata
//В каждой итерации нам нужно извлечь имя нода, сделать маленькими буквами и,
// в зависимости от того есть ли он в массиве - выполнить запись в структуру
//ИЛИ мы можем тупо искать по заданным в массиве именам, с опасностью, что какая-то сука написала капсами и это ебнет весь ридер
//
bool isMetadataAvailable = await reader.ReadToFollowingAsync("metadata", "http://www.idpf.org/2007/opf");
if (!isMetadataAvailable)
{
throw new Exception("EPUB parsing error: metadata not found in the package.");
}
while (await reader.ReadAsync() && !(reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "metadata"))
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.LocalName.ToLowerInvariant())
{
case "title":
result.Titles.Add(reader.ReadElementContentAsString());
break;
case "creator":
EpubMetadataCreator creator = new EpubMetadataCreator();
creator.Role = reader.GetAttribute("opf:role");
creator.FileAs = reader.GetAttribute("opf:file-as");
creator.Creator = reader.ReadElementContentAsString();
result.Creators.Add(creator);
break;
case "subject":
result.Subjects.Add(reader.ReadElementContentAsString());
break;
case "description":
result.Description = reader.ReadElementContentAsString();
break;
case "publisher":
result.Publishers.Add(reader.ReadElementContentAsString());
break;
case "contributor":
EpubMetadataContributor contributor = new EpubMetadataContributor();
contributor.Role = reader.GetAttribute("opf:role");
contributor.FileAs = reader.GetAttribute("opf:file-as");
contributor.Contributor = reader.ReadElementContentAsString();
result.Contributors.Add(contributor);
break;
case "date":
EpubMetadataDate date = new EpubMetadataDate();
date.Event = reader.GetAttribute("opf:event");
date.Date = reader.ReadElementContentAsString();
result.Dates.Add(date);
break;
case "type":
result.Types.Add(reader.ReadElementContentAsString());
break;
case "format":
result.Formats.Add(reader.ReadElementContentAsString());
break;
case "identifier":
EpubMetadataIdentifier identifier = new EpubMetadataIdentifier();
identifier.Id = reader.GetAttribute("id");
identifier.Scheme = reader.GetAttribute("opf:scheme");
identifier.Identifier = reader.ReadElementContentAsString();
result.Identifiers.Add(identifier);
break;
case "source":
result.Sources.Add(reader.ReadElementContentAsString());
break;
case "language":
result.Languages.Add(reader.ReadElementContentAsString());
break;
case "relation":
result.Relations.Add(reader.ReadElementContentAsString());
break;
case "coverage":
result.Coverages.Add(reader.ReadElementContentAsString());
break;
case "rights":
result.Rights.Add(reader.ReadElementContentAsString());
break;
//looks like there is an optional refining node "meta" and it is present in EPUB3
case "meta":
if (epubVersion == EpubVersion.EPUB_2)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Name = reader.GetAttribute("name");
meta.Content = reader.GetAttribute("content");
result.MetaItems.Add(meta);
}
else
if (epubVersion == EpubVersion.EPUB_3)
{
EpubMetadataMeta meta = new EpubMetadataMeta();
meta.Id = reader.GetAttribute("id");
meta.Refines = reader.GetAttribute("refines");
meta.Property = reader.GetAttribute("property");
meta.Scheme = reader.GetAttribute("scheme");
meta.Content = reader.ReadElementContentAsString();
result.MetaItems.Add(meta);
}
break;
}
break;
}
}
return(result);
}
public void build_file_creator_concrete_version(EpubVersion version, Type type)
{
var creator = i.FileEpubFactory.Initialize(version, null).BuildCreator();
creator.Should().BeOfType(type);
}
public static EpubFactory Initialize(EpubVersion version, string title, CultureInfo culture) => new EpubFactory(version, title, culture);
