@canopycanopycanopy/b-ber-lib 3.0.8-nav.0 → 3.0.8-next.101

package/dist/index.js

@@ -0,0 +1,1372 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _canopycanopycanopy_b_ber_logger = require("@canopycanopycanopy/b-ber-logger");
+_canopycanopycanopy_b_ber_logger = __toESM(_canopycanopycanopy_b_ber_logger);
+let child_process = require("child_process");
+let command_exists = require("command-exists");
+command_exists = __toESM(command_exists);
+let path = require("path");
+path = __toESM(path);
+let htmlparser2 = require("htmlparser2");
+let crypto = require("crypto");
+crypto = __toESM(crypto);
+let fs_extra = require("fs-extra");
+fs_extra = __toESM(fs_extra);
+let lodash_find_js = require("lodash/find.js");
+lodash_find_js = __toESM(lodash_find_js);
+let lodash_findIndex_js = require("lodash/findIndex.js");
+lodash_findIndex_js = __toESM(lodash_findIndex_js);
+let lodash_get_js = require("lodash/get.js");
+lodash_get_js = __toESM(lodash_get_js);
+let lodash_has_js = require("lodash/has.js");
+lodash_has_js = __toESM(lodash_has_js);
+let lodash_merge_js = require("lodash/merge.js");
+lodash_merge_js = __toESM(lodash_merge_js);
+let lodash_remove_js = require("lodash/remove.js");
+lodash_remove_js = __toESM(lodash_remove_js);
+let lodash_set_js = require("lodash/set.js");
+lodash_set_js = __toESM(lodash_set_js);
+let mime_types = require("mime-types");
+mime_types = __toESM(mime_types);
+let lodash_cloneDeep_js = require("lodash/cloneDeep.js");
+lodash_cloneDeep_js = __toESM(lodash_cloneDeep_js);
+let lodash_defaultsDeep_js = require("lodash/defaultsDeep.js");
+lodash_defaultsDeep_js = __toESM(lodash_defaultsDeep_js);
+let glob = require("glob");
+glob = __toESM(glob);
+let lodash_difference_js = require("lodash/difference.js");
+lodash_difference_js = __toESM(lodash_difference_js);
+let lodash_startCase_js = require("lodash/startCase.js");
+lodash_startCase_js = __toESM(lodash_startCase_js);
+let js_yaml = require("js-yaml");
+js_yaml = __toESM(js_yaml);
+let yawn_yaml_cjs_index_js = require("yawn-yaml/cjs/index.js");
+yawn_yaml_cjs_index_js = __toESM(yawn_yaml_cjs_index_js);
+let _canopycanopycanopy_b_ber_shapes_dublin_core = require("@canopycanopycanopy/b-ber-shapes-dublin-core");
+let layouts = require("layouts");
+layouts = __toESM(layouts);
+let vinyl = require("vinyl");
+vinyl = __toESM(vinyl);
+let lodash_uniq_js = require("lodash/uniq.js");
+lodash_uniq_js = __toESM(lodash_uniq_js);
+//#region src/EbookConvert.ts
+const command = "ebook-convert";
+const defaults = {
+	inputPath: "",
+	outputPath: "",
+	fileType: "",
+	fileName: (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-"),
+	flags: []
+};
+function checkForCalibre() {
+	return new Promise((resolve, reject) => {
+		(0, command_exists.default)(command, (err, ok) => {
+			if (err || !ok) return reject(/* @__PURE__ */ new Error("Error: calibre's ebook-convert must be installed. Download calibre here: https://calibre-ebook.com/"));
+			resolve();
+		});
+	});
+}
+function convertDocument({ inputPath, bookPath, flags }) {
+	return new Promise((resolve, reject) => {
+		(0, child_process.exec)(`${command} ${inputPath} ${bookPath} ${(flags || []).join(" ")}`, { cwd: process.cwd() }, (err, stdout, stderr) => {
+			if (err) return reject(err);
+			if (stderr !== "") process.stdout.write(stderr);
+			if (stdout !== "") process.stdout.write(stdout);
+			resolve();
+		});
+	});
+}
+function convert(options) {
+	[
+		"inputPath",
+		"outputPath",
+		"fileType"
+	].forEach((prop) => {
+		if (!Object.hasOwn(options, prop)) throw new Error(`Missing required option [${prop}]`);
+	});
+	const settings = {
+		...defaults,
+		...options,
+		bookPath: ""
+	};
+	const bookName = `${settings.fileName}.${settings.fileType.replace(/^\./, "")}`;
+	settings.bookPath = `"${path.default.resolve(settings.outputPath, bookName)}"`;
+	return checkForCalibre().then(() => convertDocument(settings)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+}
+var EbookConvert_default = { convert };
+//#endregion
+//#region src/GuideItem.ts
+var GuideItem = class {
+	fileName;
+	title;
+	type;
+	constructor({ fileName, title, type }) {
+		this.fileName = fileName;
+		this.title = title;
+		this.type = type;
+	}
+};
+//#endregion
+//#region src/Html.ts
+var Html = class {
+	static comment(str) {
+		return `\n<!-- ${str} -->\n`;
+	}
+	static escape(str) {
+		const str_ = typeof str !== "string" ? String(str) : str;
+		const map = {
+			"&": "&amp;",
+			"<": "&lt;",
+			">": "&gt;",
+			"\"": "&quot;",
+			"'": "&#39;"
+		};
+		return str_.replace(/[&<>"']/g, (m) => map[m]);
+	}
+};
+//#endregion
+//#region src/Config.ts
+var Config = class {
+	defaultOptions = {
+		env: process.env.NODE_ENV || "development",
+		src: "_project",
+		dist: "project",
+		cache: true,
+		ibooks_specified_fonts: false,
+		theme: "b-ber-theme-serif",
+		themes_directory: "./themes",
+		base_url: "http://localhost:4000/project-web",
+		base_path: "/",
+		remote_url: "http://localhost:4000/",
+		reader_url: "http://localhost:4000/project-reader",
+		downloads: [],
+		ui_options: { navigation: {
+			header_icons: {
+				info: true,
+				home: true,
+				downloads: true,
+				toc: true
+			},
+			footer_icons: {
+				chapter: true,
+				page: true
+			}
+		} },
+		private: false,
+		ignore: [],
+		autoprefixer_options: {
+			overrideBrowserslist: [
+				"defaults",
+				"> 1%",
+				"not dead",
+				"not IE 11"
+			],
+			flexbox: "no-2009"
+		},
+		layout: "columns",
+		group_footnotes: true
+	};
+	constructor(options = {}) {
+		const defaultOptionsClone = (0, lodash_cloneDeep_js.default)(this.defaultOptions);
+		return (0, lodash_defaultsDeep_js.default)((0, lodash_cloneDeep_js.default)(options), defaultOptionsClone);
+	}
+};
+//#endregion
+//#region src/SpineItem.ts
+var SpineItem = class SpineItem {
+	fileName;
+	pageOrder;
+	in_toc;
+	linear;
+	generated;
+	nodes;
+	ref;
+	title;
+	relativePath;
+	absolutePath;
+	extension;
+	name;
+	remotePath;
+	type;
+	static isNavigationDocument(fileName) {
+		return fileName === "toc" || fileName === "nav";
+	}
+	constructor({ fileName, in_toc, linear, generated, pageOrder, buildType, nodes, ref, title }) {
+		this.fileName = fileName;
+		this.pageOrder = typeof pageOrder === "number" ? pageOrder : -1;
+		this.in_toc = typeof in_toc === "boolean" ? in_toc : true;
+		this.linear = typeof linear === "boolean" ? linear : true;
+		this.generated = Boolean(generated);
+		this.nodes = nodes || [];
+		this.ref = ref || null;
+		this.title = title || (0, lodash_startCase_js.default)(fileName.toLowerCase());
+		this.relativePath = SpineItem.isNavigationDocument(this.fileName) ? this.fileName : path.default.join("text", this.fileName);
+		this.absolutePath = path.default.resolve(`project-${buildType}`, "OPS", this.relativePath);
+		this.extension = path.default.extname(this.fileName);
+		this.name = path.default.basename(this.fileName, this.extension);
+		this.remotePath = "";
+		this.type = "";
+	}
+};
+//#endregion
+//#region src/YamlAdaptor.ts
+var YamlAdaptor = class {
+	static toYaml(input) {
+		if (typeof input === "string") return js_yaml.default.safeDump(input);
+		if (typeof input === "object" && input !== null && !Array.isArray(input) || Array.isArray(input)) return js_yaml.default.safeDump(JSON.stringify(input));
+		throw new TypeError(`Invalid type: [${typeof input}]`);
+	}
+	static load(file) {
+		let data;
+		try {
+			data = fs_extra.default.readFileSync(file, "utf-8");
+		} catch (err) {
+			_canopycanopycanopy_b_ber_logger.default.error(err);
+		}
+		return data ? js_yaml.default.safeLoad(data) : [];
+	}
+	static dump(str) {
+		return js_yaml.default.safeDump(str, { indent: 2 });
+	}
+	static parse(str) {
+		return js_yaml.default.safeLoad(str);
+	}
+};
+//#endregion
+//#region src/Spine.ts
+var Spine = class {
+	src;
+	buildType;
+	frontMatter;
+	navigationConfigFile;
+	entries;
+	nested;
+	flattened;
+	constructor({ src, buildType, navigationConfigFile }) {
+		this.src = src;
+		this.buildType = buildType;
+		this.frontMatter = /* @__PURE__ */ new Map();
+		this.navigationConfigFile = navigationConfigFile;
+		this.entries = this.create();
+		this.nested = this.build(this.entries);
+		this.flattened = this.flattenNodes(this.nested);
+	}
+	build(entries = []) {
+		const { buildType } = this;
+		return entries.reduce((acc, curr, index) => {
+			let node;
+			if (typeof curr === "object" && curr !== null && !Array.isArray(curr)) {
+				const { section } = curr;
+				if (section) {
+					let _index = 0;
+					while (acc[index - _index] === void 0 && _index !== acc.length) _index += 1;
+					acc[index - _index].nodes = this.build(section);
+					return acc;
+				}
+				const [[fileName, options]] = Object.entries(curr);
+				this.frontMatter.set(fileName, {});
+				node = new SpineItem({
+					fileName,
+					buildType,
+					...options
+				});
+			} else {
+				const fileName = curr;
+				this.frontMatter.set(fileName, {});
+				node = new SpineItem({
+					fileName,
+					buildType
+				});
+			}
+			return acc.concat(node);
+		}, []);
+	}
+	flattenNodes(arr) {
+		return arr.reduce((acc, curr) => {
+			const { nodes, ...rest } = curr;
+			const acc_ = acc.concat(rest);
+			return nodes && nodes.length ? acc_.concat(this.flattenNodes(nodes)) : acc_;
+		}, []);
+	}
+	flattenYAML(data = []) {
+		return data.reduce((acc, curr) => {
+			if (typeof curr === "object" && curr !== null && !Array.isArray(curr)) {
+				if (Object.keys(curr)[0] === "section") return acc.concat(this.flattenYAML(curr.section));
+				return acc.concat(Object.keys(curr)[0]);
+			}
+			return acc.concat(curr);
+		}, []);
+	}
+	create() {
+		const pattern = path.default.resolve(this.src, "_markdown", "*.md");
+		const declaredFiles = YamlAdaptor.load(this.navigationConfigFile);
+		const flattenedFiles = this.flattenYAML(declaredFiles);
+		const missingEntries = (0, lodash_difference_js.default)(glob.default.sync(pattern).map((file) => path.default.basename(file, ".md")), flattenedFiles);
+		return declaredFiles.concat(missingEntries);
+	}
+};
+//#endregion
+//#region src/Yaml.ts
+const interfaces = {
+	metadata: {
+		term: {
+			type: "string",
+			required: true
+		},
+		value: {
+			type: "string",
+			required: true
+		},
+		term_property: {
+			type: "string",
+			required: false
+		},
+		term_property_value: {
+			type: "string",
+			required: false
+		}
+	},
+	config: {
+		env: {
+			type: "string",
+			required: false
+		},
+		src: {
+			type: "string",
+			required: true
+		},
+		dist: {
+			type: "string",
+			required: true
+		},
+		ibooks_specified_fonts: {
+			type: "boolean",
+			required: false
+		},
+		theme: {
+			type: "string",
+			required: false
+		},
+		themes_directory: {
+			type: "string",
+			required: false
+		},
+		base_url: {
+			type: "string",
+			required: false
+		},
+		base_path: {
+			type: "string",
+			required: false
+		},
+		remote_url: {
+			type: "string",
+			required: false
+		},
+		reader_url: {
+			type: "string",
+			required: false
+		},
+		downloads: {
+			type: "array",
+			required: false
+		},
+		ui_options: {
+			type: "object",
+			required: false
+		},
+		private: {
+			type: "boolean",
+			required: false
+		},
+		ignore: {
+			type: "array",
+			required: false
+		},
+		autoprefixer_options: {
+			type: "object",
+			required: false
+		},
+		layout: {
+			type: "string",
+			required: false
+		},
+		group_footnotes: {
+			type: "boolean",
+			required: false
+		}
+	},
+	media: {}
+};
+const typeCheck = (schema, data = {}) => {
+	const errors = [];
+	if (!interfaces[schema]) errors.push(/* @__PURE__ */ new Error(`Invalid schema: ${schema}`));
+	if (typeof data !== "object" || data === null || Array.isArray(data)) errors.push(/* @__PURE__ */ new Error(`Invalid entry: ${typeof data}`));
+	Object.entries(data).forEach(([key, val]) => {
+		if (!interfaces[schema]?.[key]) errors.push(/* @__PURE__ */ new Error(`Schema "${schema}" does not support property "${key}"`));
+		if (interfaces[schema]?.[key] && interfaces[schema][key].required === true && val === void 0) errors.push(/* @__PURE__ */ new Error(`Schema "${schema}" requires value for"${key}"`));
+	});
+	if (errors.length) _canopycanopycanopy_b_ber_logger.default.error(errors);
+};
+var Yaml = class {
+	data = {
+		yaml: "",
+		json: () => ({})
+	};
+	schema = "";
+	strict = true;
+	constructor(schema, strict) {
+		this.strict = strict === void 0 ? this.strict : strict;
+		if (this.strict) typeCheck(schema);
+		this.schema = schema;
+	}
+	load = (file) => {
+		const data = fs_extra.default.readFileSync(file, "utf8");
+		this.data = new yawn_yaml_cjs_index_js.default(data);
+	};
+	add = (entry) => {
+		if (this.strict) typeCheck(this.schema, entry);
+		this.data.json = [...this.data.json, entry];
+	};
+	remove = (key, value) => {
+		this.data.json = this.data.json.filter((a) => a[key] === value);
+	};
+	update = (key, current, object) => {
+		const entry = (0, lodash_find_js.default)(this.data.json, { [key]: current });
+		this.remove(key, current);
+		this.data.json = [...this.data.json, {
+			...entry,
+			...object
+		}];
+	};
+	yaml = () => this.data.yaml;
+	json = () => this.data.json;
+};
+//#endregion
+//#region src/State.ts
+const themes = {
+	"b-ber-theme-serif": require("@canopycanopycanopy/b-ber-theme-serif"),
+	"b-ber-theme-sans": require("@canopycanopycanopy/b-ber-theme-sans")
+};
+const randomHash = () => crypto.default.randomBytes(20).toString("hex");
+const skipInitialization = () => {
+	const { argv } = process;
+	return argv.includes("--help") || argv.includes("-h") || argv.includes("--version") || argv.includes("-v") || argv.length < 3 || argv.includes("new");
+};
+const SRC_DIR_IMAGES = "_images";
+const SRC_DIR_MARKDOWN = "_markdown";
+const SRC_DIR_STYLESHEETS = "_stylesheets";
+const SRC_DIR_JAVASCRIPTS = "_javascripts";
+const SRC_DIR_FONTS = "_fonts";
+const SRC_DIR_MEDIA = "_media";
+const DIST_DIR_OPS = "OPS";
+const DIST_DIR_TEXT = "text";
+const DIST_DIR_IMAGES = "images";
+const DIST_DIR_STYLESHEETS = "stylesheets";
+const DIST_DIR_JAVASCRIPTS = "javascripts";
+const DIST_DIR_FONTS = "fonts";
+const DIST_DIR_MEDIA = "media";
+var State_default = new class State {
+	static get defaults() {
+		return {
+			build: "epub",
+			sequence: [],
+			hash: randomHash()
+		};
+	}
+	metadata = { json: () => [{}] };
+	theme = {};
+	video = [];
+	audio = [];
+	media = {};
+	build = "epub";
+	sequence = [];
+	hash = randomHash();
+	builds = {
+		sample: {},
+		epub: {},
+		mobi: {},
+		pdf: {},
+		web: {},
+		reader: {}
+	};
+	config;
+	version;
+	get spine() {
+		return this.builds[this.build].spine;
+	}
+	set spine(val) {
+		this.builds[this.build].spine = val;
+	}
+	get guide() {
+		return this.builds[this.build].guide;
+	}
+	set guide(val) {
+		this.builds[this.build].guide = val;
+	}
+	get figures() {
+		return this.builds[this.build].figures;
+	}
+	set figures(val) {
+		this.builds[this.build].figures = val;
+	}
+	get footnotes() {
+		return this.builds[this.build].footnotes;
+	}
+	set footnotes(val) {
+		this.builds[this.build].footnotes = val;
+	}
+	get cursor() {
+		return this.builds[this.build].cursor;
+	}
+	set cursor(val) {
+		this.builds[this.build].cursor = val;
+	}
+	get toc() {
+		return this.builds[this.build].toc;
+	}
+	set toc(val) {
+		this.builds[this.build].toc = val;
+	}
+	get remoteAssets() {
+		return this.builds[this.build].remoteAssets;
+	}
+	set remoteAssets(val) {
+		this.builds[this.build].remoteAssets = val;
+	}
+	get loi() {
+		return this.builds[this.build].loi;
+	}
+	set loi(val) {
+		this.builds[this.build].loi = val;
+	}
+	get srcDir() {
+		return this.config.src;
+	}
+	set srcDir(val) {
+		this.config.src = val;
+	}
+	get distDir() {
+		if (this.build && this.builds && this.builds[this.build]) return this.builds[this.build].dist;
+		return this.config.dist;
+	}
+	set distDir(val) {
+		this.config.dist = val;
+	}
+	get env() {
+		return process.env.NODE_ENV || "development";
+	}
+	set env(val) {
+		this.config.env = val;
+	}
+	src = {
+		root: (...args) => path.default.join(this.srcDir, ...args),
+		images: (...args) => path.default.join(this.srcDir, SRC_DIR_IMAGES, ...args),
+		markdown: (...args) => path.default.join(this.srcDir, SRC_DIR_MARKDOWN, ...args),
+		stylesheets: (...args) => path.default.join(this.srcDir, SRC_DIR_STYLESHEETS, ...args),
+		javascripts: (...args) => path.default.join(this.srcDir, SRC_DIR_JAVASCRIPTS, ...args),
+		fonts: (...args) => path.default.join(this.srcDir, SRC_DIR_FONTS, ...args),
+		media: (...args) => path.default.join(this.srcDir, SRC_DIR_MEDIA, ...args)
+	};
+	dist = {
+		root: (...args) => path.default.join(this.distDir, ...args),
+		ops: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, ...args),
+		text: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_TEXT, ...args),
+		images: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_IMAGES, ...args),
+		stylesheets: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_STYLESHEETS, ...args),
+		javascripts: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_JAVASCRIPTS, ...args),
+		fonts: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_FONTS, ...args),
+		media: (...args) => path.default.join(this.distDir, DIST_DIR_OPS, DIST_DIR_MEDIA, ...args)
+	};
+	constructor() {
+		let version;
+		try {
+			({version} = fs_extra.default.readJSONSync(require.resolve("./package.json")));
+		} catch (err) {
+			({version} = fs_extra.default.readJSONSync(require.resolve("../package.json")));
+		}
+		(0, lodash_set_js.default)(this, "version", version);
+		(0, lodash_set_js.default)(this, "config", new Config());
+		this.reset();
+		this.loadMetadata();
+		this.loadAudioVideo();
+		this.loadMedia();
+		this.loadBuilds();
+		this.loadTheme();
+	}
+	reset = () => {
+		Object.entries(State.defaults).forEach(([key, val]) => (0, lodash_set_js.default)(this, key, val));
+		this.loadConfig();
+	};
+	add = (prop, value) => {
+		const prevValue = (0, lodash_get_js.default)(this, prop);
+		if (Array.isArray(prevValue)) (0, lodash_set_js.default)(this, prop, [...prevValue, value]);
+		else if (typeof prevValue === "object" && prevValue !== null && !Array.isArray(prevValue)) (0, lodash_set_js.default)(this, prop, {
+			...prevValue,
+			value
+		});
+		else if (typeof prevValue === "string") (0, lodash_set_js.default)(this, prop, `${prevValue}${value}`);
+		else _canopycanopycanopy_b_ber_logger.default.error(`Cannot add [${value}] to [state.${prop}]`);
+	};
+	remove = (prop, value) => {
+		const prevValue = (0, lodash_get_js.default)(this, prop);
+		if (Array.isArray(prevValue)) {
+			const arr = [...prevValue];
+			(0, lodash_remove_js.default)(arr, value);
+			(0, lodash_set_js.default)(this, prop, arr);
+		} else if (typeof prevValue === "object" && prevValue !== null && !Array.isArray(prevValue)) {
+			const key = value;
+			const { [key]: _, ...rest } = prevValue;
+			(0, lodash_set_js.default)(this, prop, rest);
+		} else _canopycanopycanopy_b_ber_logger.default.error(`Cannot remove [${value}] from [state.${prop}]`);
+	};
+	merge = (prop, value) => {
+		const oldValue = (0, lodash_get_js.default)(this, prop);
+		(0, lodash_set_js.default)(this, prop, (0, lodash_merge_js.default)(oldValue, value));
+	};
+	update = (prop, val) => {
+		(0, lodash_set_js.default)(this, prop, val);
+	};
+	has = (prop) => {
+		return (0, lodash_has_js.default)(this, prop);
+	};
+	contains = (coll, value) => this.indexOf(coll, value) > -1;
+	find = (coll, pred) => {
+		return (0, lodash_find_js.default)((0, lodash_get_js.default)(this, coll), pred);
+	};
+	indexOf = (coll, pred) => {
+		return (0, lodash_findIndex_js.default)((0, lodash_get_js.default)(this, coll), pred);
+	};
+	loadConfig = () => {
+		if (!fs_extra.default.existsSync(path.default.resolve("config.yml"))) return;
+		const config = new Yaml("config");
+		config.load(path.default.resolve("config.yml"));
+		(0, lodash_set_js.default)(this, "config", new Config(config.json()));
+	};
+	loadMetadata = () => {
+		const fpath = path.default.resolve(this.config.src, "metadata.yml");
+		if (!fs_extra.default.existsSync(fpath)) return;
+		(0, lodash_set_js.default)(this, "metadata", new Yaml("metadata"));
+		this.metadata.load(fpath);
+	};
+	loadMedia = () => {
+		const fpath = path.default.resolve(this.config.src, "media.yml");
+		if (!fs_extra.default.existsSync(fpath)) return;
+		const mediaYaml = new Yaml("media");
+		mediaYaml.load(fpath);
+		const media = mediaYaml.json();
+		(0, lodash_set_js.default)(this, "media", media);
+	};
+	loadTheme = () => {
+		if (skipInitialization()) return;
+		const userThemesPath = path.default.resolve(this.config.themes_directory);
+		fs_extra.default.ensureDirSync(userThemesPath);
+		module.paths.push(userThemesPath);
+		const cwdArr = process.cwd().split("/");
+		const modulePaths = new Set([...module.paths]);
+		let cwdPath;
+		do {
+			cwdPath = `${cwdArr.join("/")}/node_modules`;
+			if (modulePaths.has(cwdPath)) continue;
+			module.paths.push(cwdPath);
+		} while (cwdArr.pop());
+		const themeName = this.config.theme;
+		if (themes[themeName]) {
+			(0, lodash_set_js.default)(this, "theme", themes[themeName]);
+			_canopycanopycanopy_b_ber_logger.default.info(`Loaded theme [${themeName}]`);
+			return;
+		}
+		try {
+			(0, lodash_set_js.default)(this, "theme", require(themeName));
+			_canopycanopycanopy_b_ber_logger.default.info(`Loaded theme [${themeName}]`);
+		} catch (err) {
+			_canopycanopycanopy_b_ber_logger.default.warn(`There was an error during require [${themeName}]`);
+			_canopycanopycanopy_b_ber_logger.default.warn("Using default theme [b-ber-theme-serif]");
+			_canopycanopycanopy_b_ber_logger.default.warn(err.message);
+			(0, lodash_set_js.default)(this, "theme", themes["b-ber-theme-serif"]);
+		}
+	};
+	loadAudioVideo = () => {
+		if (skipInitialization()) return;
+		const mediaPath = path.default.resolve(this.config.src, "_media");
+		fs_extra.default.ensureDirSync(mediaPath);
+		const media = fs_extra.default.readdirSync(mediaPath);
+		const video = media.filter((a) => /^video/.test(mime_types.default.lookup(a)));
+		const audio = media.filter((a) => /^audio/.test(mime_types.default.lookup(a)));
+		(0, lodash_set_js.default)(this, "video", video);
+		(0, lodash_set_js.default)(this, "audio", audio);
+	};
+	loadBuildSettings = (type) => {
+		if (skipInitialization()) return void 0;
+		const src = this.config.src;
+		const dist = this.config.dist;
+		const projectDir = path.default.resolve(src);
+		if (!fs_extra.default.existsSync(projectDir)) _canopycanopycanopy_b_ber_logger.default.error(`Project directory [${projectDir}] does not exist`);
+		const navigationConfigFileDefaultPath = path.default.resolve(src, "toc.yml");
+		const navigationConfigFilePath = path.default.resolve(src, `${type}.yml`);
+		const spine = new Spine({
+			src,
+			buildType: type,
+			navigationConfigFile: fs_extra.default.existsSync(navigationConfigFilePath) ? navigationConfigFilePath : navigationConfigFileDefaultPath
+		});
+		const config = this.config[type] ? { ...this.config[type] } : {};
+		return {
+			src,
+			dist: `${dist}-${type}`,
+			config,
+			guide: [],
+			spine,
+			toc: spine.nested,
+			cursor: [],
+			figures: [],
+			footnotes: [],
+			remoteAssets: [],
+			loi: []
+		};
+	};
+	loadBuilds = () => {
+		[
+			"sample",
+			"epub",
+			"mobi",
+			"pdf",
+			"web",
+			"reader",
+			"xml"
+		].forEach((build) => (0, lodash_set_js.default)(this.builds, build, this.loadBuildSettings(build)));
+	};
+}();
+//#endregion
+//#region src/HtmlToXml.ts
+var HtmlToXmlParser = class {
+	customElementNames;
+	inlineElementNames;
+	whitelistedAttributes;
+	blacklistedTagNames;
+	containingTagNames;
+	elementAttributeNames;
+	elementAttributeTransformers;
+	content;
+	onEndCallback;
+	output;
+	tagList;
+	constructor({ content, onEndCallback }) {
+		this.customElementNames = {
+			pullquote: true,
+			blockquote: true,
+			epigraph: true,
+			dialogue: true,
+			gallery: true,
+			spread: true,
+			colophon: true,
+			appendix: true,
+			subtitle: true,
+			frontmatter: true,
+			backmatter: true,
+			"meta-content": true,
+			bibliography: true,
+			masthead: true,
+			figcaption: true,
+			subchapter: true
+		};
+		this.inlineElementNames = {
+			pagebreak: true,
+			a: false,
+			abbr: true,
+			acronym: true,
+			audio: false,
+			b: true,
+			bdi: true,
+			bdo: true,
+			big: true,
+			br: false,
+			button: false,
+			canvas: true,
+			cite: true,
+			code: true,
+			data: true,
+			datalist: true,
+			del: true,
+			dfn: true,
+			em: true,
+			embed: false,
+			i: true,
+			iframe: false,
+			img: false,
+			input: false,
+			ins: true,
+			kbd: true,
+			label: false,
+			map: true,
+			mark: true,
+			meter: true,
+			noscript: false,
+			object: false,
+			output: true,
+			picture: false,
+			progress: false,
+			q: true,
+			ruby: true,
+			s: true,
+			samp: true,
+			script: false,
+			select: false,
+			slot: true,
+			small: true,
+			span: true,
+			strong: true,
+			sub: true,
+			sup: true,
+			svg: true,
+			template: true,
+			textarea: false,
+			time: true,
+			u: true,
+			tt: true,
+			var: true,
+			video: false,
+			wbr: true
+		};
+		this.whitelistedAttributes = {
+			src: true,
+			href: true,
+			"xlink:href": true,
+			xmlns: true,
+			"xmlns:xlink": true,
+			class: true
+		};
+		this.blacklistedTagNames = {
+			html: true,
+			head: true,
+			title: true,
+			meta: true,
+			link: true,
+			script: true,
+			body: true,
+			video: true,
+			audio: true
+		};
+		this.containingTagNames = {
+			div: true,
+			span: true,
+			section: true
+		};
+		this.elementAttributeNames = {
+			img: { src: "href" },
+			source: { src: "href" }
+		};
+		this.elementAttributeTransformers = {
+			img: { src: (value) => `file://${path.default.resolve(State_default.dist.images(path.default.basename(value)))}` },
+			source: { src: (value) => `file://${path.default.resolve(State_default.dist.media(path.default.basename(value)))}` }
+		};
+		this.content = content;
+		this.onEndCallback = onEndCallback;
+		this.output = "";
+		this.tagList = [];
+		this.onopentag = this.onopentag.bind(this);
+		this.ontext = this.ontext.bind(this);
+		this.onclosetag = this.onclosetag.bind(this);
+		this.onend = this.onend.bind(this);
+	}
+	writePageBreak() {
+		this.output += "<pagebreak></pagebreak>";
+	}
+	writeXMLDeclaration() {
+		this.output += "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+	}
+	renameAttribute(name, attribute) {
+		if (!this.elementAttributeNames[name]) return attribute;
+		return this.elementAttributeNames[name][attribute] || attribute;
+	}
+	transformAttributeValue(name, attribute, value) {
+		if (!this.elementAttributeTransformers[name] || !this.elementAttributeTransformers[name][attribute]) return value;
+		return this.elementAttributeTransformers[name][attribute](value);
+	}
+	writeTagOpen(name, attributes = {}) {
+		let tag = [name];
+		tag = Object.entries(attributes).reduce((acc, [key, val]) => this.whitelistedAttributes[key] ? acc.concat(`${this.renameAttribute(name, key)}="${this.transformAttributeValue(name, key, val)}"`) : acc, tag);
+		if (attributes.class) {
+			const classNames = new Set(attributes.class.split(" "));
+			if (classNames.has("figure__large") && classNames.has("figure__inline") || classNames.has("gallery__item")) this.writePageBreak();
+		}
+		this.output += `<${tag.join(" ")}>`;
+	}
+	writeTagClose(name) {
+		this.output += `</${name}>`;
+		if (!this.inlineElementNames[name]) this.output += "\n";
+	}
+	addTag(name) {
+		this.tagList.push(name);
+	}
+	removeTag() {
+		return this.tagList.pop();
+	}
+	getTag() {
+		if (!this.tagList.length) return null;
+		return this.tagList[this.tagList.length - 1];
+	}
+	onopentag(name, attributes = {}) {
+		if (this.blacklistedTagNames[name]) return;
+		let tagName = name;
+		if (tagName === "body") {
+			if (attributes.class) tagName = attributes.class.replace(/\s+/g, "-");
+		} else if (tagName === "source") {
+			if (!attributes.src || !/\.mp[34]$/i.test(attributes.src)) return;
+		} else if (this.containingTagNames[tagName]) {
+			if (attributes.class) {
+				const classNames = attributes.class.split(" ");
+				for (let i = 0; i < classNames.length; i++) if (this.customElementNames[classNames[i]]) tagName = classNames[i];
+			}
+		}
+		this.addTag(tagName);
+		this.writeTagOpen(tagName, attributes);
+	}
+	ontext(text) {
+		if (!text.trim()) return;
+		const name = this.getTag();
+		if (!name || this.blacklistedTagNames[name]) return;
+		this.output += text;
+	}
+	onclosetag() {
+		const name = this.removeTag();
+		if (name) this.writeTagClose(name);
+	}
+	onend() {
+		this.writeTagClose("body");
+		this.onEndCallback(this.output);
+	}
+	parse() {
+		this.writeXMLDeclaration();
+		this.writeTagOpen("body");
+		const parser = new htmlparser2.Parser({
+			onclosetag: this.onclosetag,
+			onopentag: this.onopentag,
+			ontext: this.ontext,
+			onend: this.onend
+		}, { decodeEntities: false });
+		parser.write(this.content);
+		parser.end();
+	}
+};
+//#endregion
+//#region src/ManifestItemProperties.ts
+var ManifestItemProperties = class ManifestItemProperties {
+	static HTMLMimeTypes = ["text/html", "application/xhtml+xml"];
+	static isHTML(file) {
+		return ManifestItemProperties.HTMLMimeTypes.includes(mime_types.default.lookup(file.absolutePath));
+	}
+	static isNav(file) {
+		return ManifestItemProperties.isHTML(file) && /^toc\./.test(file.name);
+	}
+	static isScripted(file) {
+		if (!ManifestItemProperties.isHTML(file)) return false;
+		if (ManifestItemProperties.isNav(file)) return true;
+		return fs_extra.default.readFileSync(file.absolutePath, "utf8").match(/<script/) !== null;
+	}
+	static isSVG(file) {
+		if (!ManifestItemProperties.isHTML(file)) return false;
+		return fs_extra.default.readFileSync(file.absolutePath, "utf8").match(/<svg/) !== null;
+	}
+	static isDCElement(data) {
+		return Object.hasOwn(data, "term") && _canopycanopycanopy_b_ber_shapes_dublin_core.elements.indexOf(data.term) > -1;
+	}
+	static isDCTerm(data) {
+		return Object.hasOwn(data, "term") && _canopycanopycanopy_b_ber_shapes_dublin_core.terms.indexOf(data.term) > -1;
+	}
+	static hasRemoteResources(file) {
+		if (!ManifestItemProperties.isHTML(file)) return false;
+		return fs_extra.default.readFileSync(file.absolutePath, "utf8").match(/src=(?:['"]{1})?(?:http|\/\/)/) !== null;
+	}
+	static testHTML(file) {
+		const props = [];
+		if (ManifestItemProperties.isNav(file)) props.push("nav");
+		if (ManifestItemProperties.isScripted(file)) props.push("scripted");
+		if (ManifestItemProperties.isSVG(file)) props.push("svg");
+		if (ManifestItemProperties.hasRemoteResources(file)) props.push("remote-resources");
+		return props;
+	}
+	static testMeta(data) {
+		return {
+			term: ManifestItemProperties.isDCTerm(data),
+			element: ManifestItemProperties.isDCElement(data)
+		};
+	}
+};
+//#endregion
+//#region src/Template.ts
+var Template = class {
+	static render = (contents, template) => (0, layouts.default)(new vinyl.default({
+		path: ".Template",
+		layout: "template",
+		contents: Buffer.from(contents)
+	}), { template }).contents.toString();
+};
+//#endregion
+//#region src/Url.ts
+var Url = class Url {
+	static trimSlashes(url) {
+		return url.replace(/(^\/+|\/+$)/, "");
+	}
+	static removeTrailingSlash = (str) => {
+		if (typeof str !== "string") return "";
+		return str.replace(/\/+$/, "");
+	};
+	static addTrailingSlash = (str) => {
+		if (typeof str !== "string" || str === "/") return "/";
+		return `${Url.removeTrailingSlash(str)}/`;
+	};
+	static ensureDecoded(str) {
+		let str_ = str;
+		while (decodeURIComponent(str_) !== str_) str_ = decodeURIComponent(str_);
+		return str_;
+	}
+	static encodeQueryString(url) {
+		const parts = url.split("?");
+		const loc = parts[0];
+		let qs = parts[1];
+		if (!qs) return loc;
+		qs = Url.ensureDecoded(qs);
+		qs = encodeURIComponent(qs);
+		return `${loc}?${qs}`;
+	}
+};
+//#endregion
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	createUnsupportedInline: () => createUnsupportedInline,
+	ensure: () => ensure,
+	ensurePoster: () => ensurePoster,
+	ensureSource: () => ensureSource,
+	ensureSupportedClassNames: () => ensureSupportedClassNames,
+	fail: () => fail,
+	fileId: () => fileId,
+	generateWebpubManifest: () => generateWebpubManifest,
+	getBookMetadata: () => getBookMetadata,
+	getImageOrientation: () => getImageOrientation,
+	getMediaType: () => getMediaType,
+	getTitle: () => getTitle,
+	opsPath: () => opsPath,
+	renderCaption: () => renderCaption,
+	renderPosterImage: () => renderPosterImage,
+	resolveIntersectingUrl: () => resolveIntersectingUrl,
+	safeWrite: () => safeWrite,
+	validatePosterImage: () => validatePosterImage
+});
+const opsPath = (fpath, base) => fpath.replace(new RegExp(`^${base}${path.default.sep}OPS${path.default.sep}?`), "");
+const fileId = (str) => `_${str.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+const getImageOrientation = (w, h) => {
+	const widthToHeight = w / h;
+	let imageType = null;
+	if (widthToHeight < .61) imageType = "portrait-high";
+	if (widthToHeight >= .61 && widthToHeight < 1) imageType = "portrait";
+	if (widthToHeight === 1) imageType = "square";
+	if (widthToHeight > 1) imageType = "landscape";
+	return imageType;
+};
+const getTitle = (page) => {
+	if (page.name === "figures-titlepage") return "Figures";
+	const meta = State_default.spine.frontMatter.get(page.name);
+	return meta && meta.title ? meta.title : page.title || page.name;
+};
+const getBookMetadata = (term) => {
+	const entry = (0, lodash_find_js.default)(State_default.metadata.json(), { term });
+	if (entry && entry.value) return entry.value;
+	_canopycanopycanopy_b_ber_logger.default.warn(`Could not find metadata value for ${term}`);
+	return "";
+};
+const safeWrite = (dest, data) => fs_extra.default.existsSync(dest) ? Promise.resolve() : fs_extra.default.writeFile(dest, data);
+const fail = (_msg, _err, yargs) => {
+	yargs.showHelp();
+	process.exit(0);
+};
+const ensureDirs = (dirs, prefix) => {
+	const cwd = process.cwd();
+	const dirs_ = (0, lodash_uniq_js.default)([
+		`${prefix}/_project`,
+		`${prefix}/_project/_fonts`,
+		`${prefix}/_project/_images`,
+		`${prefix}/_project/_javascripts`,
+		`${prefix}/_project/_markdown`,
+		`${prefix}/_project/_media`,
+		`${prefix}/_project/_stylesheets`,
+		`${prefix}/themes`
+	].concat(dirs)).map((a) => fs_extra.default.ensureDir(path.default.join(cwd, a)));
+	return Promise.all(dirs_);
+};
+const ensureFiles = (files, prefix) => {
+	const files_ = [{
+		absolutePath: path.default.resolve(prefix, "_project", "toc.yml"),
+		content: ""
+	}].filter(({ absolutePath }) => (0, lodash_findIndex_js.default)(files, { absolutePath }) < 0).concat(files).reduce((acc, curr) => fs_extra.default.existsSync(curr.absolutePath) ? acc : acc.concat(fs_extra.default.writeFile(curr.absolutePath, curr.content)), []);
+	return Promise.all(files_);
+};
+const ensure = ({ files = [], dirs = [], prefix = "" } = {}) => ensureDirs(dirs, prefix).then(() => ensureFiles(files, prefix)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+const trimLeadingSlash = (s) => s.replace(/^\//, "");
+const resolveIntersectingUrl = (u, p) => {
+	let url;
+	try {
+		url = new URL(u);
+	} catch (err) {
+		_canopycanopycanopy_b_ber_logger.default.warn(`${err.message}: "${u}"`);
+		return u;
+	}
+	const { pathname } = url;
+	let urlParts = pathname.split("/").filter(Boolean);
+	let pathParts = p.split("/").filter(Boolean);
+	if (/\./.test(urlParts[urlParts.length - 1])) urlParts.pop();
+	let intersectionIndices = [];
+	for (let i = 0; i < urlParts.length; i++) for (let j = 0; j < pathParts.length; j++) if (urlParts[i] === pathParts[j]) {
+		intersectionIndices = [i, j];
+		break;
+	}
+	const [uIdx, pIdx] = intersectionIndices;
+	urlParts = urlParts.slice(0, uIdx);
+	pathParts = pathParts.slice(pIdx);
+	const intersection = urlParts.concat(pathParts);
+	url.pathname = intersection.join("/");
+	return url.href;
+};
+const webpubManifestResource = (base) => (file) => {
+	return {
+		href: resolveIntersectingUrl(base, file),
+		type: mime_types.default.lookup(file)
+	};
+};
+const webpubManifestReadingOrderItem = (base) => ({ title, file }) => {
+	return {
+		href: resolveIntersectingUrl(base, file),
+		title,
+		type: "text/xhtml"
+	};
+};
+const generateWebpubManifest = (files) => {
+	const remoteURL = Url.trimSlashes(State_default.config.remote_url);
+	const fileMap = new Map(files.map((f) => [path.default.basename(f), f]));
+	const readingOrder = State_default.spine.flattened.reduce((acc, curr) => {
+		const file = fileMap.get(`${curr.fileName}.xhtml`);
+		return !file ? acc : acc.concat({
+			file,
+			title: curr.title
+		});
+	}, []).map(webpubManifestReadingOrderItem(remoteURL));
+	const resources = files.filter((file) => path.default.basename(file).charAt(0) !== ".").map(webpubManifestResource(remoteURL));
+	return {
+		"@context": "https://readium.org/webpub-manifest/context.jsonld",
+		metadata: {
+			"@type": "http://schema.org/Book",
+			title: getBookMetadata("title"),
+			author: getBookMetadata("creator"),
+			identifier: getBookMetadata("identifier"),
+			language: getBookMetadata("language"),
+			publisher: getBookMetadata("publisher"),
+			modified: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		links: [{
+			rel: "self",
+			href: `${remoteURL}/${trimLeadingSlash(State_default.distDir)}/manifest.json`,
+			type: "application/webpub+json"
+		}],
+		readingOrder,
+		resources
+	};
+};
+const validatePosterImage = (asset, type) => {
+	const assetPath = State_default.src.images(asset);
+	if (!fs_extra.default.existsSync(assetPath)) _canopycanopycanopy_b_ber_logger.default.error(`bber-directives: Poster image for [${type}] does not exist`);
+	return asset;
+};
+const renderPosterImage = (poster) => poster ? `<img src="${poster}" alt="Poster Image"/>` : "";
+const renderCaption = (caption, mediaType) => caption ? `<p class="caption caption__${mediaType}">${caption}</p>` : "";
+const getMediaType = (type) => {
+	const index = type.indexOf("-");
+	return index > -1 ? type.substring(0, index) : type;
+};
+function createUnsupportedInline({ id, commentStart, commentEnd, attrString, mediaType, poster }) {
+	return `
+    ${commentStart}
+    <section class="${mediaType} figure__large figure__inline">
+      <div id="${id}" ${attrString}>
+        <div class="media__fallback media__fallback__${mediaType} media__fallback--image">
+          <figure>
+            ${renderPosterImage(poster)}
+          </figure>
+        </div>
+        <p class="media__fallback media__fallback__${mediaType} media__fallback--text">Your device does not support embedded media.</p>
+      </div>
+    </section>
+    ${commentEnd}`;
+}
+function ensureSource(obj, type, fileName, lineNumber) {
+	if (!obj.source) _canopycanopycanopy_b_ber_logger.default.error(`Directive [${type}] requires a [source] attribute at [${fileName}:${lineNumber}]`);
+}
+function ensurePoster(obj, type) {
+	if (!obj.poster) return;
+	validatePosterImage(obj.poster, type);
+	obj.poster = `../images/${encodeURIComponent(path.default.basename(obj.poster))}`;
+}
+function ensureSupportedClassNames(obj, supported) {
+	obj.classes += ` embed ${supported(State_default.build) ? "" : "un"}supported`;
+}
+//#endregion
+//#region src/Theme.ts
+const defaultThemes = {
+	"b-ber-theme-serif": require("@canopycanopycanopy/b-ber-theme-serif"),
+	"b-ber-theme-sans": require("@canopycanopycanopy/b-ber-theme-sans")
+};
+const getVendorThemes = () => {
+	const packageJSON = path.default.resolve("package.json");
+	if (!fs_extra.default.existsSync(packageJSON)) return [];
+	let themes = [];
+	const { dependencies, devDependencies } = fs_extra.default.readJSONSync(packageJSON);
+	const deps = dependencies ? Object.keys(dependencies) : [];
+	const devDeps = devDependencies ? Object.keys(devDependencies) : [];
+	themes = themes.concat(deps, devDeps);
+	themes = themes.filter((name) => /^b-ber-theme/.test(name));
+	return themes;
+};
+const getUserThemes = () => {
+	const dir = path.default.resolve(State_default.config.themes_directory);
+	if (!fs_extra.default.existsSync(dir)) {
+		_canopycanopycanopy_b_ber_logger.default.warn(`Themes directory [${path.default.basename(dir)}] does not exist`);
+		return [];
+	}
+	return fs_extra.default.readdirSync(dir).reduce((acc, curr) => fs_extra.default.lstatSync(path.default.resolve(dir, curr)).isDirectory() ? acc.concat(curr) : acc, []);
+};
+const getThemeList = (themes, current = "") => {
+	const themes_ = (0, lodash_uniq_js.default)(themes);
+	const duplicates = [];
+	return {
+		text: themes_.reduce((acc, curr) => {
+			let curr_ = `${current === curr ? "✓" : "○"} ${curr}`;
+			if (themes.indexOf(curr) !== themes.lastIndexOf(curr)) {
+				duplicates.push(curr);
+				curr_ += " [(duplicate)]";
+			}
+			curr_ += "\n";
+			return acc.concat(curr_);
+		}, "").slice(0, -1),
+		duplicates
+	};
+};
+const getThemes = () => {
+	const current = State_default.config.theme ? State_default.config.theme : "";
+	const userThemes = getUserThemes();
+	const vendorThemes = getVendorThemes();
+	return {
+		current,
+		themes: [
+			...Object.keys(defaultThemes),
+			...userThemes,
+			...vendorThemes
+		]
+	};
+};
+const createProjectThemeDirectory = (name) => fs_extra.default.mkdirp(path.default.resolve(State_default.config.src, "_stylesheets", name)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+const copyThemeAssets = (theme) => {
+	const themePath = path.default.dirname(theme.entry);
+	const themeSettings = path.default.join(themePath, "_settings.scss");
+	const settingsPath = path.default.resolve(State_default.src.stylesheets(theme.name, "_settings.scss"));
+	const overridesPath = path.default.resolve(State_default.src.stylesheets(theme.name, "_overrides.scss"));
+	const fontsPath = path.default.resolve(State_default.src.fonts());
+	const imagesPath = path.default.resolve(State_default.src.images());
+	return fs_extra.default.copy(themeSettings, settingsPath, { overwrite: false }).then(() => safeWrite(overridesPath, "")).then(() => {
+		if (!theme.fonts.length) return;
+		const promises = theme.fonts.map((font) => {
+			const fontPath = path.default.join(themePath, "fonts", font);
+			return fs_extra.default.copy(fontPath, path.default.join(fontsPath, font), { overwrite: false });
+		});
+		return Promise.all(promises);
+	}).then(() => {
+		if (!theme.images.length) return;
+		const promises = theme.images.map((image) => {
+			const imagePath = path.default.join(themePath, "images", image);
+			return fs_extra.default.copy(imagePath, path.default.join(imagesPath, image), { overwrite: false });
+		});
+		return Promise.all(promises);
+	});
+};
+const updateConfig = (name) => {
+	const configPath = path.default.resolve("config.yml");
+	const config = YamlAdaptor.load(configPath);
+	config.theme = name;
+	const config_ = YamlAdaptor.dump(config);
+	return fs_extra.default.writeFile(configPath, config_);
+};
+var Theme = class {
+	static list = () => {
+		const { current, themes } = getThemes();
+		const { text, duplicates } = getThemeList(themes, current);
+		_canopycanopycanopy_b_ber_logger.default.notice("The following themes are available:", "\n", text);
+		if (duplicates.length) {
+			_canopycanopycanopy_b_ber_logger.default.notice("Duplicate themes have been found in both the [node_modules] and [themes] directory");
+			_canopycanopycanopy_b_ber_logger.default.notice("Resolve this issue by either removing the duplicate directory from [themes] or by running [npm rm <location> <package>]");
+		}
+	};
+	static set = (name, force = false) => {
+		let theme;
+		const cwdArr = process.cwd().split("/");
+		const modulePaths = new Set([...module.paths]);
+		let cwdPath;
+		do {
+			cwdPath = `${cwdArr.join("/")}/node_modules`;
+			if (modulePaths.has(cwdPath)) continue;
+			module.paths.push(cwdPath);
+		} while (cwdArr.pop());
+		if (defaultThemes[name]) theme = defaultThemes[name];
+		else try {
+			theme = require(name);
+		} catch (err) {
+			_canopycanopycanopy_b_ber_logger.default.error(`Could not load theme [${name}]`);
+		}
+		return createProjectThemeDirectory(name).then(() => copyThemeAssets(theme)).then(() => updateConfig(name)).then(() => !force && _canopycanopycanopy_b_ber_logger.default.notice(`Updated theme [${name}]`)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	};
+};
+//#endregion
+exports.EbookConvert = EbookConvert_default;
+exports.GuideItem = GuideItem;
+exports.Html = Html;
+exports.HtmlToXml = HtmlToXmlParser;
+exports.ManifestItemProperties = ManifestItemProperties;
+exports.Spine = Spine;
+exports.SpineItem = SpineItem;
+exports.State = State_default;
+exports.Template = Template;
+exports.Theme = Theme;
+exports.Url = Url;
+exports.YamlAdaptor = YamlAdaptor;
+Object.defineProperty(exports, "utils", {
+	enumerable: true,
+	get: function() {
+		return utils_exports;
+	}
+});