@canopycanopycanopy/b-ber-tasks 3.0.8-nav-memo.4 → 3.0.8-next.96

package/dist/index.js

@@ -1,182 +1,2115 @@
-"use strict";
-
-var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-_Object$defineProperty(exports, "clean", {
-  enumerable: true,
-  get: function () {
-    return _clean.default;
-  }
-});
-_Object$defineProperty(exports, "container", {
-  enumerable: true,
-  get: function () {
-    return _container.default;
-  }
-});
-_Object$defineProperty(exports, "copy", {
-  enumerable: true,
-  get: function () {
-    return _copy.default;
-  }
-});
-_Object$defineProperty(exports, "cover", {
-  enumerable: true,
-  get: function () {
-    return _cover.default;
-  }
-});
-_Object$defineProperty(exports, "deploy", {
-  enumerable: true,
-  get: function () {
-    return _deploy.default;
-  }
-});
-_Object$defineProperty(exports, "epub", {
-  enumerable: true,
-  get: function () {
-    return _epub.default;
-  }
-});
-_Object$defineProperty(exports, "footnotes", {
-  enumerable: true,
-  get: function () {
-    return _footnotes.default;
-  }
-});
-_Object$defineProperty(exports, "generate", {
-  enumerable: true,
-  get: function () {
-    return _generate.default;
-  }
-});
-_Object$defineProperty(exports, "init", {
-  enumerable: true,
-  get: function () {
-    return _init.default;
-  }
-});
-_Object$defineProperty(exports, "inject", {
-  enumerable: true,
-  get: function () {
-    return _inject.default;
-  }
-});
-_Object$defineProperty(exports, "loi", {
-  enumerable: true,
-  get: function () {
-    return _loi.default;
-  }
-});
-_Object$defineProperty(exports, "mobi", {
-  enumerable: true,
-  get: function () {
-    return _mobi.default;
-  }
+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_lib_State = require("@canopycanopycanopy/b-ber-lib/State");
+_canopycanopycanopy_b_ber_lib_State = __toESM(_canopycanopycanopy_b_ber_lib_State);
+let _canopycanopycanopy_b_ber_logger = require("@canopycanopycanopy/b-ber-logger");
+_canopycanopycanopy_b_ber_logger = __toESM(_canopycanopycanopy_b_ber_logger);
+let fs_extra = require("fs-extra");
+fs_extra = __toESM(fs_extra);
+let path = require("path");
+path = __toESM(path);
+let _canopycanopycanopy_b_ber_templates_Xml = require("@canopycanopycanopy/b-ber-templates/Xml");
+_canopycanopycanopy_b_ber_templates_Xml = __toESM(_canopycanopycanopy_b_ber_templates_Xml);
+let lodash_isArray_js = require("lodash/isArray.js");
+lodash_isArray_js = __toESM(lodash_isArray_js);
+let _canopycanopycanopy_b_ber_lib = require("@canopycanopycanopy/b-ber-lib");
+let _canopycanopycanopy_b_ber_lib_utils = require("@canopycanopycanopy/b-ber-lib/utils");
+let _canopycanopycanopy_b_ber_templates_Xhtml = require("@canopycanopycanopy/b-ber-templates/Xhtml");
+_canopycanopycanopy_b_ber_templates_Xhtml = __toESM(_canopycanopycanopy_b_ber_templates_Xhtml);
+let crypto = require("crypto");
+crypto = __toESM(crypto);
+let image_size = require("image-size");
+image_size = __toESM(image_size);
+let pureimage = require("pureimage");
+pureimage = __toESM(pureimage);
+let _canopycanopycanopy_b_ber_lib_YamlAdaptor = require("@canopycanopycanopy/b-ber-lib/YamlAdaptor");
+_canopycanopycanopy_b_ber_lib_YamlAdaptor = __toESM(_canopycanopycanopy_b_ber_lib_YamlAdaptor);
+let child_process = require("child_process");
+let readline = require("readline");
+readline = __toESM(readline);
+let epub_zipper = require("epub-zipper");
+epub_zipper = __toESM(epub_zipper);
+let _canopycanopycanopy_b_ber_shapes_sequences_sequences = require("@canopycanopycanopy/b-ber-shapes-sequences/sequences");
+_canopycanopycanopy_b_ber_shapes_sequences_sequences = __toESM(_canopycanopycanopy_b_ber_shapes_sequences_sequences);
+let _canopycanopycanopy_b_ber_lib_Theme = require("@canopycanopycanopy/b-ber-lib/Theme");
+_canopycanopycanopy_b_ber_lib_Theme = __toESM(_canopycanopycanopy_b_ber_lib_Theme);
+let _canopycanopycanopy_b_ber_resources = require("@canopycanopycanopy/b-ber-resources");
+_canopycanopycanopy_b_ber_resources = __toESM(_canopycanopycanopy_b_ber_resources);
+let _canopycanopycanopy_b_ber_templates_Project = require("@canopycanopycanopy/b-ber-templates/Project");
+_canopycanopycanopy_b_ber_templates_Project = __toESM(_canopycanopycanopy_b_ber_templates_Project);
+let vinyl = require("vinyl");
+vinyl = __toESM(vinyl);
+let _canopycanopycanopy_b_ber_templates_figures = require("@canopycanopycanopy/b-ber-templates/figures");
+_canopycanopycanopy_b_ber_templates_figures = __toESM(_canopycanopycanopy_b_ber_templates_figures);
+let lodash_sortBy_js = require("lodash/sortBy.js");
+lodash_sortBy_js = __toESM(lodash_sortBy_js);
+let _canopycanopycanopy_b_ber_lib_EbookConvert = require("@canopycanopycanopy/b-ber-lib/EbookConvert");
+_canopycanopycanopy_b_ber_lib_EbookConvert = __toESM(_canopycanopycanopy_b_ber_lib_EbookConvert);
+let css = require("css");
+css = __toESM(css);
+let _canopycanopycanopy_b_ber_templates_Opf_Manifest = require("@canopycanopycanopy/b-ber-templates/Opf/Manifest");
+_canopycanopycanopy_b_ber_templates_Opf_Manifest = __toESM(_canopycanopycanopy_b_ber_templates_Opf_Manifest);
+let _canopycanopycanopy_b_ber_templates_Opf_Metadata = require("@canopycanopycanopy/b-ber-templates/Opf/Metadata");
+_canopycanopycanopy_b_ber_templates_Opf_Metadata = __toESM(_canopycanopycanopy_b_ber_templates_Opf_Metadata);
+let layouts = require("layouts");
+layouts = __toESM(layouts);
+let lodash_has_js = require("lodash/has.js");
+lodash_has_js = __toESM(lodash_has_js);
+let recursive_readdir = require("recursive-readdir");
+recursive_readdir = __toESM(recursive_readdir);
+let _canopycanopycanopy_b_ber_templates_Ncx = require("@canopycanopycanopy/b-ber-templates/Ncx");
+_canopycanopycanopy_b_ber_templates_Ncx = __toESM(_canopycanopycanopy_b_ber_templates_Ncx);
+let _canopycanopycanopy_b_ber_templates_Opf_Guide = require("@canopycanopycanopy/b-ber-templates/Opf/Guide");
+_canopycanopycanopy_b_ber_templates_Opf_Guide = __toESM(_canopycanopycanopy_b_ber_templates_Opf_Guide);
+let _canopycanopycanopy_b_ber_templates_Opf_Spine = require("@canopycanopycanopy/b-ber-templates/Opf/Spine");
+_canopycanopycanopy_b_ber_templates_Opf_Spine = __toESM(_canopycanopycanopy_b_ber_templates_Opf_Spine);
+let _canopycanopycanopy_b_ber_templates_Toc = require("@canopycanopycanopy/b-ber-templates/Toc");
+_canopycanopycanopy_b_ber_templates_Toc = __toESM(_canopycanopycanopy_b_ber_templates_Toc);
+let glob = require("glob");
+glob = __toESM(glob);
+let lodash_difference_js = require("lodash/difference.js");
+lodash_difference_js = __toESM(lodash_difference_js);
+let lodash_find_js = require("lodash/find.js");
+lodash_find_js = __toESM(lodash_find_js);
+let lodash_remove_js = require("lodash/remove.js");
+lodash_remove_js = __toESM(lodash_remove_js);
+let _canopycanopycanopy_b_ber_templates_Opf_Pkg = require("@canopycanopycanopy/b-ber-templates/Opf/Pkg");
+_canopycanopycanopy_b_ber_templates_Opf_Pkg = __toESM(_canopycanopycanopy_b_ber_templates_Opf_Pkg);
+let lodash_kebabCase_js = require("lodash/kebabCase.js");
+lodash_kebabCase_js = __toESM(lodash_kebabCase_js);
+let _canopycanopycanopy_b_ber_markdown_renderer = require("@canopycanopycanopy/b-ber-markdown-renderer");
+_canopycanopycanopy_b_ber_markdown_renderer = __toESM(_canopycanopycanopy_b_ber_markdown_renderer);
+let autoprefixer = require("autoprefixer");
+autoprefixer = __toESM(autoprefixer);
+let postcss = require("postcss");
+postcss = __toESM(postcss);
+let sass = require("sass");
+sass = __toESM(sass);
+let uglify_js = require("uglify-js");
+uglify_js = __toESM(uglify_js);
+let _canopycanopycanopy_b_ber_validator = require("@canopycanopycanopy/b-ber-validator");
+_canopycanopycanopy_b_ber_validator = __toESM(_canopycanopycanopy_b_ber_validator);
+let cheerio = require("cheerio");
+cheerio = __toESM(cheerio);
+let lodash_findIndex_js = require("lodash/findIndex.js");
+lodash_findIndex_js = __toESM(lodash_findIndex_js);
+let _canopycanopycanopy_b_ber_lib_HtmlToXml = require("@canopycanopycanopy/b-ber-lib/HtmlToXml");
+_canopycanopycanopy_b_ber_lib_HtmlToXml = __toESM(_canopycanopycanopy_b_ber_lib_HtmlToXml);
+let lodash_isPlainObject_js = require("lodash/isPlainObject.js");
+lodash_isPlainObject_js = __toESM(lodash_isPlainObject_js);
+let lodash_isString_js = require("lodash/isString.js");
+lodash_isString_js = __toESM(lodash_isString_js);
+let browser_sync = require("browser-sync");
+let lodash_debounce_js = require("lodash/debounce.js");
+lodash_debounce_js = __toESM(lodash_debounce_js);
+//#region src/clean/index.ts
+const clean = () => {
+	const projectRoot = path.default.dirname(_canopycanopycanopy_b_ber_lib_State.default.distDir);
+	const fileType = `.${_canopycanopycanopy_b_ber_lib_State.default.build}`;
+	const promises = fs_extra.default.readdirSync(projectRoot).filter((a) => path.default.extname(a) === fileType).map((b) => fs_extra.default.remove(path.default.join(projectRoot, b)).then(() => _canopycanopycanopy_b_ber_logger.default.info("clean remove [%s]", b)));
+	return Promise.all(promises).then(() => fs_extra.default.remove(_canopycanopycanopy_b_ber_lib_State.default.distDir).then(() => _canopycanopycanopy_b_ber_logger.default.info("clean remove [%s]", _canopycanopycanopy_b_ber_lib_State.default.distDir)));
+};
+var clean_default = () => clean().catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/container/index.ts
+var Container = class {
+	get dirs() {
+		return [_canopycanopycanopy_b_ber_lib_State.default.dist.ops(), _canopycanopycanopy_b_ber_lib_State.default.dist.root("META-INF")];
+	}
+	constructor() {
+		this.init = this.init.bind(this);
+	}
+	write() {
+		const promises = [{
+			path: path.default.join("META-INF", "container.xml"),
+			content: _canopycanopycanopy_b_ber_templates_Xml.default.container()
+		}, {
+			path: "mimetype",
+			content: _canopycanopycanopy_b_ber_templates_Xml.default.mimetype()
+		}].map((file) => fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.root(file.path), file.content).then(() => _canopycanopycanopy_b_ber_logger.default.info("container emit [%s]", file.path)));
+		return Promise.all(promises);
+	}
+	makedirs() {
+		const promises = this.dirs.map((dir) => fs_extra.default.mkdirs(dir).then(() => _canopycanopycanopy_b_ber_logger.default.info("container emit [%s]", dir)));
+		return Promise.all(promises);
+	}
+	init() {
+		return this.makedirs().then(() => this.write()).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+var container_default = new Container().init;
+//#endregion
+//#region src/copy/index.ts
+const FILE_SIZE_WARNING_LIMIT = 15e5;
+const cwd$1 = process.cwd();
+const copy = () => {
+	const ignoreMap = ((0, lodash_isArray_js.default)(_canopycanopycanopy_b_ber_lib_State.default.config.ignore) ? _canopycanopycanopy_b_ber_lib_State.default.config.ignore : []).reduce((acc, curr) => {
+		acc[path.default.resolve(cwd$1, curr)] = true;
+		return acc;
+	}, {});
+	const promises = [
+		{
+			from: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.src.images()),
+			to: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.dist.images())
+		},
+		{
+			from: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.src.fonts()),
+			to: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.dist.fonts())
+		},
+		{
+			from: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.src.media()),
+			to: path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.dist.media())
+		}
+	].filter((dir) => !ignoreMap[dir.from]).map((dir) => fs_extra.default.mkdirp(dir.to).then(() => fs_extra.default.mkdirp(dir.from)).then(() => fs_extra.default.copy(dir.from, dir.to, {
+		overwrite: false,
+		filter: (file) => path.default.basename(file).charAt(0) !== "." && !ignoreMap[file]
+	})).then(() => fs_extra.default.readdir(dir.to)).then((files) => {
+		const baseTo = `${path.default.basename(dir.to)}`;
+		files.forEach((file) => {
+			const { size } = fs_extra.default.statSync(path.default.join(dir.to, file));
+			_canopycanopycanopy_b_ber_logger.default.info("copy [%s - {%d}]", `${baseTo}/${file}`, size);
+			if (size > FILE_SIZE_WARNING_LIMIT) _canopycanopycanopy_b_ber_logger.default.warn("copy [%s - {%d}] Large file sizes may cause performance issues in some output formats", file, size);
+		});
+	}));
+	return Promise.all(promises).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+//#endregion
+//#region src/cover/index.ts
+var Cover = class {
+	metadata;
+	metadataYAML;
+	coverPrefix;
+	coverXHTMLContent;
+	coverEntry;
+	coverImagePath;
+	width;
+	height;
+	fontSize;
+	lineHeight;
+	marginLeft;
+	marginTop;
+	colorBackground;
+	colorText;
+	fontName;
+	fontFile;
+	posY;
+	constructor() {
+		const defaultMetadata = {
+			title: "",
+			creator: "",
+			"date-modified": String(/* @__PURE__ */ new Date()),
+			identifier: ""
+		};
+		const fileMetadata = this.YAMLToObject();
+		this.metadata = {
+			...defaultMetadata,
+			...fileMetadata
+		};
+		this.metadataYAML = _canopycanopycanopy_b_ber_lib_State.default.src.root("metadata.yml");
+		this.coverPrefix = "__bber_cover__";
+		this.coverXHTMLContent = "";
+		this.coverEntry = "";
+		this.coverImagePath = "";
+		this.width = 1600;
+		this.height = 2400;
+		this.fontSize = 45;
+		this.lineHeight = this.fontSize * 1.35;
+		this.marginLeft = this.fontSize * 2;
+		this.marginTop = this.fontSize * 2;
+		this.colorBackground = "#5050c5";
+		this.colorText = "#ffffff";
+		this.fontName = "Free Universal";
+		this.fontFile = "freeuniversal-bold-webfont.ttf";
+		this.posY = 0;
+	}
+	getPosY = () => {
+		this.posY = this.posY ? this.posY + this.lineHeight : this.marginTop + this.fontSize;
+		return this.posY;
+	};
+	loadInitialState = async () => {
+		this.posY = 0;
+		this.coverXHTMLContent = "";
+		this.coverEntry = "";
+		this.coverImagePath = "";
+	};
+	YAMLToObject() {
+		return _canopycanopycanopy_b_ber_lib_State.default.metadata.json().reduce((acc, curr) => {
+			if (curr.term && curr.value) acc[curr.term] = curr.value;
+			return acc;
+		}, {});
+	}
+	removeDefaultCovers() {
+		const imageDir = _canopycanopycanopy_b_ber_lib_State.default.src.images();
+		const covers = fs_extra.default.readdirSync(imageDir).filter((file) => path.default.basename(file).match(new RegExp(this.coverPrefix)));
+		if (!covers.length) return Promise.resolve();
+		const promises = covers.map((file) => fs_extra.default.remove(path.default.join(imageDir, file)).then(() => _canopycanopycanopy_b_ber_logger.default.info("cover remove outdated cover image [%s]", file)));
+		return Promise.all(promises);
+	}
+	wrapText(ctx, text) {
+		const maxWidth = this.width - this.marginLeft * 2;
+		const words = text.split(" ");
+		let line = "";
+		for (let n = 0; n < words.length; n++) {
+			const testLine = `${line}${words[n]} `;
+			if (ctx.measureText(testLine).width > maxWidth && n > 0) {
+				ctx.fillText(line, this.marginLeft, this.getPosY());
+				line = `${words[n]} `;
+			} else line = testLine;
+		}
+		ctx.fillText(line, this.marginLeft, this.getPosY());
+	}
+	generateDefaultCoverImage() {
+		return new Promise((resolve) => {
+			const img = pureimage.default.make(this.width, this.height);
+			const ctx = img.getContext("2d");
+			return pureimage.default.registerFont(path.default.join(__dirname, this.fontFile), this.fontName).load(() => {
+				ctx.fillStyle = this.colorBackground;
+				ctx.fillRect(0, 0, this.width, this.height);
+				ctx.font = `${this.fontSize}px '${this.fontName}'`;
+				ctx.fillStyle = this.colorText;
+				ctx.fillText("Title", this.marginLeft, this.getPosY());
+				ctx.fillText(this.metadata.title, this.marginLeft, this.getPosY());
+				ctx.fillText("", this.marginLeft, this.getPosY());
+				ctx.fillText("Creator", this.marginLeft, this.getPosY());
+				ctx.fillText(this.metadata.creator, this.marginLeft, this.getPosY());
+				ctx.fillText("", this.marginLeft, this.getPosY());
+				ctx.fillText("Publisher", this.marginLeft, this.getPosY());
+				ctx.fillText(this.metadata.publisher, this.marginLeft, this.getPosY());
+				ctx.fillText("", this.marginLeft, this.getPosY());
+				ctx.fillText("Description", this.marginLeft, this.getPosY());
+				this.wrapText(ctx, this.metadata.description);
+				ctx.fillText("", this.marginLeft, this.getPosY());
+				ctx.fillText("b-ber version", this.marginLeft, this.getPosY());
+				ctx.fillText(_canopycanopycanopy_b_ber_lib_State.default.version, this.marginLeft, this.getPosY());
+				return pureimage.default.encodeJPEGToStream(img, fs_extra.default.createWriteStream(this.coverImagePath)).then(() => {
+					_canopycanopycanopy_b_ber_logger.default.info("cover generated image [%s]", this.coverImagePath);
+					resolve();
+				}).catch(_canopycanopycanopy_b_ber_logger.default.error);
+			});
+		});
+	}
+	writeCoverXHTML = async () => {
+		if (_canopycanopycanopy_b_ber_lib_State.default.build === "pdf") return;
+		const textDir = _canopycanopycanopy_b_ber_lib_State.default.dist.text();
+		const coverFilePath = _canopycanopycanopy_b_ber_lib_State.default.dist.text("cover.xhtml");
+		await fs_extra.default.mkdirp(textDir);
+		await fs_extra.default.writeFile(coverFilePath, this.coverXHTMLContent);
+		_canopycanopycanopy_b_ber_logger.default.info("cover wrote XML [cover.xhtml]");
+	};
+	generateCoverXHTML() {
+		const { width, height } = (0, image_size.default)(this.coverImagePath);
+		const href = `images/${encodeURIComponent(this.coverEntry)}`;
+		const svg = _canopycanopycanopy_b_ber_templates_Xhtml.default.cover({
+			width,
+			height,
+			href
+		});
+		this.coverXHTMLContent = _canopycanopycanopy_b_ber_lib.Template.render(svg, _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+		_canopycanopycanopy_b_ber_logger.default.info("cover build [cover.xhtml]");
+	}
+	addCoverToMetadata() {
+		return fs_extra.default.writeFile(this.metadataYAML, _canopycanopycanopy_b_ber_lib_State.default.metadata.yaml());
+	}
+	createCoverImage() {
+		this.coverEntry = `${this.coverPrefix}${crypto.default.randomBytes(20).toString("hex")}.jpg`;
+		this.coverImagePath = _canopycanopycanopy_b_ber_lib_State.default.src.images(this.coverEntry);
+		const metadata = _canopycanopycanopy_b_ber_lib.YamlAdaptor.load(this.metadataYAML);
+		const coverListedInMetadata = (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("cover");
+		if (coverListedInMetadata) {
+			this.coverEntry = coverListedInMetadata.replace(/_jpg$/, ".jpg");
+			_canopycanopycanopy_b_ber_logger.default.info("cover verify image [%s]", this.coverEntry);
+			this.coverImagePath = _canopycanopycanopy_b_ber_lib_State.default.src.images(this.coverEntry);
+			if (!fs_extra.default.existsSync(this.coverImagePath)) _canopycanopycanopy_b_ber_logger.default.error("Cover image listed in metadata.yml cannot be found");
+			return this.generateCoverXHTML();
+		}
+		_canopycanopycanopy_b_ber_logger.default.info("cover generated image [%s]", this.coverEntry);
+		const coverMetadata = {
+			term: "cover",
+			value: this.coverEntry
+		};
+		_canopycanopycanopy_b_ber_lib_State.default.metadata.add(coverMetadata);
+		this.metadata = {
+			...coverMetadata,
+			...this.metadata,
+			...metadata
+		};
+		return this.removeDefaultCovers().then(() => this.generateDefaultCoverImage()).then(() => this.generateCoverXHTML()).then(() => this.addCoverToMetadata()).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+	init = () => this.loadInitialState().then(() => this.createCoverImage()).then(() => this.writeCoverXHTML()).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+var cover_default = new Cover().init;
+//#endregion
+//#region src/deploy/index.ts
+const cwd = process.cwd();
+const defaultBuilds = [
+	"epub",
+	"mobi",
+	"reader"
+];
+const args = new Map([
+	["epub", "--include \"*.epub\""],
+	["mobi", "--include \"*.mobi\""],
+	["pdf", "--include \"*.pdf\""],
+	["xml", "--include \"*.xml\""],
+	["reader", "--include \"project-reader/*\""],
+	["web", "--include \"project-web/*\""]
+]);
+const cacheArgsBucket = [
+	"--recursive",
+	"--acl public-read",
+	"--expires 2034-01-01T00:00:00Z",
+	"--cache-control max-age=31536000,public"
+];
+const cacheArgsFiles = [
+	"--recursive",
+	"--exclude \"*\"",
+	"--include \"*.ncx\"",
+	"--include \"*.opf\"",
+	"--include \"*.json\"",
+	"--include \"*.epub\"",
+	"--include \"*.mobi\"",
+	"--include \"*.pdf\"",
+	"--include \"*.xml\"",
+	"--metadata-directive REPLACE",
+	"--acl public-read",
+	"--expires 1970-01-01T00:00:00Z",
+	"--cache-control max-age=0,public"
+];
+const cacheArgsHTML = [
+	"--recursive",
+	"--exclude \"*\"",
+	"--include \"*.html\"",
+	"--include \"*.xhtml\"",
+	"--acl public-read",
+	"--metadata-directive REPLACE",
+	"--content-type text/html",
+	"--expires 1970-01-01T00:00:00Z",
+	"--cache-control max-age=0,public"
+];
+async function ensureAwsCli() {
+	try {
+		(0, child_process.execSync)("aws --version > /dev/null 2>&1", { cwd });
+	} catch (err) {
+		console.log("AWS CLI must be installed to run deploy");
+		console.log("See installation instructions here: https://docs.aws.amazon.com/cli/latest/userguide/installing.html");
+		process.exit(0);
+	}
+}
+function run(command, callback) {
+	const proc = (0, child_process.exec)(command, { cwd });
+	proc.stdout?.on("data", (data) => console.log(String(data)));
+	proc.stderr?.on("data", (data) => console.log(String(data)));
+	proc.on("error", (err) => {
+		console.log("");
+		console.log("ERROR: aws encountered an error");
+		console.log(err.message);
+		console.log(err.stack);
+	});
+	proc.on("close", (code) => {
+		if (code !== 0) {
+			console.log("");
+			console.log(`ERROR: aws exited with code ${code}`);
+		}
+		if (callback) callback();
+	});
+}
+function deploy({ bucketURL, awsRegion, builds }) {
+	console.log("");
+	console.log("Uploading project files...");
+	return new Promise((resolve) => {
+		const commandParts = [
+			`aws s3 cp ${path.default.resolve(cwd, "./")} ${bucketURL}`,
+			"--recursive",
+			"--exclude \"*\"",
+			`--region ${awsRegion}`
+		];
+		builds.forEach((arg) => {
+			const val = args.get(arg);
+			if (val) commandParts.push(val);
+		});
+		return run(commandParts.join(" "), () => resolve());
+	});
+}
+function ensureEnvVars() {
+	const { AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, BBER_BUCKET_REGION } = process.env;
+	if (!AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY || !BBER_BUCKET_REGION) _canopycanopycanopy_b_ber_logger.default.error("[AWS_ACCESS_KEY_ID], [AWS_SECRET_ACCESS_KEY] and [BBER_BUCKET_REGION] must be set to deploy the project");
+	const configFile = path.default.resolve(cwd, "config.yml");
+	const { bucket_url: bucketURL } = _canopycanopycanopy_b_ber_lib_YamlAdaptor.default.load(configFile);
+	if (!bucketURL) _canopycanopycanopy_b_ber_logger.default.error("[bucketURL] must be set in config.yml to deploy the project");
+	return {
+		bucketURL,
+		awsRegion: BBER_BUCKET_REGION
+	};
+}
+function extractVars(config) {
+	const { bucketURL, awsRegion } = config;
+	let builds = config.builds && config.builds.length ? config.builds : defaultBuilds;
+	builds = builds.map((str) => str.toLowerCase()).filter((arg) => args.has(arg));
+	return {
+		bucketURL,
+		awsRegion,
+		builds
+	};
+}
+function deployWithPrompt(config) {
+	return new Promise((resolve) => {
+		const rl = readline.default.createInterface(process.stdin, process.stdout);
+		const { bucketURL, awsRegion, builds } = config;
+		console.log("");
+		console.log("Does the following look OK?");
+		console.log("");
+		console.log(` Bucket URL:    ${bucketURL}`);
+		console.log(` AWS Region:    ${awsRegion}`);
+		console.log(` Builds:        ${builds.join(", ")}`);
+		console.log("");
+		rl.setPrompt(" [yN] ");
+		rl.prompt();
+		rl.on("line", (data) => {
+			if (data === "y" || data === "yes") return deploy({
+				bucketURL,
+				awsRegion,
+				builds
+			}).then(() => rl.close());
+			process.exit(0);
+		}).on("close", resolve);
+	});
+}
+function deployWithoutPrompt(config) {
+	_canopycanopycanopy_b_ber_logger.default.notice("Deploy command run with \"--yes\", skipping confirmation");
+	return deploy(config);
+}
+function setCachePolicy({ bucketURL, awsRegion }, cacheArgs) {
+	console.log("Setting cache policy...");
+	const command = [`aws s3 cp ${bucketURL} ${bucketURL}`, `--region ${awsRegion}`].concat(cacheArgs).join(" ");
+	return new Promise((resolve) => run(command, () => resolve()));
+}
+function main({ builds, yes }) {
+	let config = {};
+	return ensureAwsCli().then(ensureEnvVars).then((response) => {
+		config = extractVars({
+			...response,
+			builds
+		});
+		if (yes) return deployWithoutPrompt(config);
+		return deployWithPrompt(config);
+	}).then(() => setCachePolicy(config, cacheArgsBucket)).then(() => setCachePolicy(config, cacheArgsFiles)).then(() => setCachePolicy(config, cacheArgsHTML)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+}
+//#endregion
+//#region src/epub/index.ts
+const epub = () => process.argv.includes("--no-compile") ? Promise.resolve() : epub_zipper.default.create({
+	input: _canopycanopycanopy_b_ber_lib_State.default.distDir,
+	output: process.cwd(),
+	clean: true,
+	fileName: (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("identifier")
+}).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/footnotes/index.ts
+var Footnotes = class {
+	baseName;
+	get file() {
+		return {
+			name: this.baseName,
+			path: _canopycanopycanopy_b_ber_lib_State.default.dist.text(`${this.baseName}.xhtml`)
+		};
+	}
+	constructor() {
+		this.baseName = "notes";
+		this.init = this.init.bind(this);
+	}
+	async writeFootnotes() {
+		const notes = _canopycanopycanopy_b_ber_lib_State.default.footnotes.reduce((acc, cur) => acc.concat(cur.notes), "");
+		const markup = _canopycanopycanopy_b_ber_lib.Template.render(notes, _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+		await fs_extra.default.writeFile(this.file.path, markup, "utf8");
+		const fileData = new _canopycanopycanopy_b_ber_lib.SpineItem({
+			fileName: this.file.name,
+			in_toc: false,
+			linear: false,
+			generated: true,
+			buildType: _canopycanopycanopy_b_ber_lib_State.default.build
+		});
+		_canopycanopycanopy_b_ber_lib_State.default.add("spine.flattened", fileData);
+		_canopycanopycanopy_b_ber_logger.default.info(`create default footnotes page [${this.file.name}.xhtml]`);
+	}
+	init() {
+		if (!_canopycanopycanopy_b_ber_lib_State.default.footnotes.length) {
+			_canopycanopycanopy_b_ber_logger.default.info("footnotes no footnotes found in source");
+			return Promise.resolve(_canopycanopycanopy_b_ber_lib_State.default.footnotes);
+		}
+		_canopycanopycanopy_b_ber_logger.default.info("footnotes generating links");
+		return this.writeFootnotes().catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+var footnotes_default = new Footnotes().init;
+//#endregion
+//#region src/generate/index.ts
+var Generate = class {
+	constructor() {
+		this.init = this.init.bind(this);
+	}
+	createFile({ markdownDir, metadata }) {
+		const frontmatter = `---\n${Object.entries(metadata).reduce((acc, [k, v]) => v ? acc.concat(`${k}: ${v}\n`) : acc, "")}---\n`;
+		const { title } = metadata;
+		const fileName = `${title.replace(/[^a-z0-9_-]/gi, "-")}.md`;
+		const filePath = path.default.join(markdownDir, fileName);
+		if (fs_extra.default.existsSync(filePath)) _canopycanopycanopy_b_ber_logger.default.error(`_markdown${path.default.sep}${fileName} already exists, aborting`);
+		return fs_extra.default.writeFile(filePath, frontmatter).then(() => ({ fileName }));
+	}
+	writePageMeta({ fileName }) {
+		const tocFile = _canopycanopycanopy_b_ber_lib_State.default.src.root("toc.yml");
+		const index = (_canopycanopycanopy_b_ber_lib_YamlAdaptor.default.load(tocFile) || []).indexOf(fileName);
+		const content = `\n- ${path.default.basename(fileName, ".md")}`;
+		if (index > -1) throw new Error(`${fileName} already exists in [${path.default.basename(tocFile)}]. Aborting`);
+		const promises = [fs_extra.default.appendFile(tocFile, content)];
+		Object.keys(_canopycanopycanopy_b_ber_shapes_sequences_sequences.default).reduce((acc, curr) => fs_extra.default.existsSync(_canopycanopycanopy_b_ber_lib_State.default.src.root(`${curr}.yml`)) ? acc.concat(fs_extra.default.appendFile(_canopycanopycanopy_b_ber_lib_State.default.src.root(`${curr}.yml`), content)) : acc, promises);
+		return Promise.all(promises).then(() => ({ fileName }));
+	}
+	init(metadata) {
+		const markdownDir = _canopycanopycanopy_b_ber_lib_State.default.src.markdown();
+		return fs_extra.default.mkdirp(markdownDir).then(() => this.createFile({
+			markdownDir,
+			metadata
+		})).then((resp) => this.writePageMeta(resp)).then(({ fileName }) => _canopycanopycanopy_b_ber_logger.default.notice(`Generated new page [${fileName}]`)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+const generate = new Generate().init;
+//#endregion
+//#region src/init/index.ts
+var Initializer = class {
+	src;
+	dist;
+	name;
+	config;
+	path;
+	builds;
+	constructor({ name = "", config } = {}) {
+		this.src = "_project";
+		this.dist = "project";
+		this.name = name;
+		this.config = config || {};
+		this.path = path.default.join(name, this.src);
+		this.builds = Object.keys(_canopycanopycanopy_b_ber_shapes_sequences_sequences.default);
+		if (fs_extra.default.existsSync(this.path)) _canopycanopycanopy_b_ber_logger.default.error(`Project [${name}] already exits, aborting`);
+	}
+	createAssets = () => {
+		return (0, _canopycanopycanopy_b_ber_lib_utils.ensure)({
+			files: [
+				_canopycanopycanopy_b_ber_templates_Project.default.tocYAML(this.path),
+				_canopycanopycanopy_b_ber_templates_Project.default.configYAML(this.path, this.config),
+				_canopycanopycanopy_b_ber_templates_Project.default.metadataYAML(this.path),
+				..._canopycanopycanopy_b_ber_templates_Project.default.javascripts(this.path),
+				..._canopycanopycanopy_b_ber_templates_Project.default.stylesheets(),
+				..._canopycanopycanopy_b_ber_templates_Project.default.markdown(this.path),
+				_canopycanopycanopy_b_ber_templates_Project.default.readme(this.path),
+				_canopycanopycanopy_b_ber_templates_Project.default.gitignore(this.path)
+			],
+			dirs: _canopycanopycanopy_b_ber_templates_Project.default.directories(this.path),
+			prefix: this.name
+		});
+	};
+	copyImages() {
+		return (0, _canopycanopycanopy_b_ber_resources.default)().then((assets) => {
+			const { "b-ber-logo": bberLogo, "default-publishers-logo": publishersLogo } = assets;
+			const images = [bberLogo, publishersLogo];
+			_canopycanopycanopy_b_ber_logger.default.info("Copying development assets");
+			const promises = images.map((a) => fs_extra.default.copy(a, path.default.join(this.path, "_images", path.default.basename(a))));
+			return Promise.all(promises);
+		});
+	}
+	setTheme() {
+		const { theme } = _canopycanopycanopy_b_ber_lib_State.default.config;
+		process.chdir(this.name);
+		return _canopycanopycanopy_b_ber_lib_Theme.default.set(theme, true);
+	}
+	start() {
+		this.createAssets().then(() => this.copyImages()).then(() => this.setTheme()).then(() => _canopycanopycanopy_b_ber_logger.default.notice(`Created new project [${this.name}]`)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+//#endregion
+//#region src/inject/index.ts
+const getRemoteAssets = (type) => Promise.resolve(_canopycanopycanopy_b_ber_lib_State.default.config[`remote_${type}`] || []);
+const getAssets = (type) => Promise.all([fs_extra.default.readdir(_canopycanopycanopy_b_ber_lib_State.default.dist.ops(type)), getRemoteAssets(type)]).then(([a, b]) => [...a, ...b]);
+const getInlineScripts = () => [new vinyl.default({ contents: Buffer.from(`window.bber = window.bber || {}; window.bber.env = '${_canopycanopycanopy_b_ber_lib_State.default.build}';`) })];
+const ensureString = (objectOrString) => objectOrString instanceof vinyl.default ? objectOrString.contents?.toString() ?? "" : objectOrString;
+const relative = (from, to) => path.default.relative(path.default.join(...from), path.default.join(...to));
+const render$1 = ({ file, basePath, stylesheets, javascripts, inlineStylesheets, inlineJavascripts, metadata }) => {
+	const stylesheets_ = stylesheets.map(ensureString).map((f) => _canopycanopycanopy_b_ber_lib.Template.render(relative([basePath], ["stylesheets", f]), _canopycanopycanopy_b_ber_templates_Xhtml.default.stylesheet())).join("");
+	const inlineStylesheets_ = inlineStylesheets.map(ensureString).map((f) => _canopycanopycanopy_b_ber_lib.Template.render(f, _canopycanopycanopy_b_ber_templates_Xhtml.default.stylesheet(true))).join("");
+	const javascripts_ = javascripts.map(ensureString).map((f) => _canopycanopycanopy_b_ber_lib.Template.render(relative([basePath], ["javascripts", f]), _canopycanopycanopy_b_ber_templates_Xhtml.default.javascript())).join("");
+	const inlineJavascripts_ = inlineJavascripts.map(ensureString).map((f) => _canopycanopycanopy_b_ber_lib.Template.render(f, _canopycanopycanopy_b_ber_templates_Xhtml.default.javascript(true))).join("");
+	const metadata_ = metadata.map(ensureString).map((f) => _canopycanopycanopy_b_ber_lib.Template.render(f, _canopycanopycanopy_b_ber_templates_Xhtml.default.jsonLD())).join("");
+	return `${_canopycanopycanopy_b_ber_lib.Template.render(`${stylesheets_}${inlineStylesheets_}`, _canopycanopycanopy_b_ber_templates_Xhtml.default.head())}${file instanceof vinyl.default ? file.contents?.toString() ?? "" : fs_extra.default.readFileSync(_canopycanopycanopy_b_ber_lib_State.default.dist.ops(basePath, file), "utf8")}${_canopycanopycanopy_b_ber_lib.Template.render(`${javascripts_}${inlineJavascripts_}${metadata_}`, _canopycanopycanopy_b_ber_templates_Xhtml.default.tail())}`;
+};
+const writeAll = (files) => Promise.all(files.map((file) => fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.text(file.fileName), file.contents)));
+const getFileObjects = async (files, basePath = "") => {
+	const stylesheets = await getAssets("stylesheets");
+	const javascripts = await getAssets("javascripts");
+	const inlineStylesheets = [];
+	const inlineJavascripts = getInlineScripts();
+	const metadata = [];
+	return files.map((file) => ({
+		fileName: file.name,
+		contents: render$1({
+			file: file.data,
+			basePath,
+			stylesheets,
+			javascripts,
+			inlineStylesheets,
+			inlineJavascripts,
+			metadata
+		})
+	}));
+};
+const inject = async () => {
+	const basePath = "text";
+	return writeAll(await getFileObjects(fs_extra.default.readdirSync(_canopycanopycanopy_b_ber_lib_State.default.dist.ops(basePath)).map((file) => ({
+		name: file,
+		data: file
+	})), basePath)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+//#endregion
+//#region src/loi/index.ts
+const createLOILeader = () => {
+	const baseName = "figures-titlepage";
+	const fileName = `${baseName}.xhtml`;
+	const markup = _canopycanopycanopy_b_ber_lib.Template.render(_canopycanopycanopy_b_ber_templates_Xhtml.default.loi(), _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+	const guideItem = new _canopycanopycanopy_b_ber_lib.GuideItem({
+		fileName,
+		title: "Figures",
+		type: "loi"
+	});
+	_canopycanopycanopy_b_ber_lib_State.default.add("guide", guideItem);
+	if (_canopycanopycanopy_b_ber_lib_State.default.indexOf("spine.flattened", (item) => item.fileName === baseName) < 0) {
+		const item = {
+			fileName: baseName,
+			in_toc: true,
+			ref: null,
+			pageOrder: -1,
+			generated: true
+		};
+		_canopycanopycanopy_b_ber_lib_State.default.add("spine.entries", baseName);
+		_canopycanopycanopy_b_ber_lib_State.default.add("spine.nested", new _canopycanopycanopy_b_ber_lib.SpineItem(item));
+		_canopycanopycanopy_b_ber_lib_State.default.add("spine.flattened", item);
+	}
+	_canopycanopycanopy_b_ber_logger.default.info(`loi emit default figures titlepage [${fileName}]`);
+	return fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.text(fileName), markup, "utf8");
+};
+const createLOIAsSingleHTMLFile = () => {
+	const classes = (item) => item.classes ? item.classes.replace(/small/g, "inline") : "";
+	const figuresPage = _canopycanopycanopy_b_ber_lib_State.default.figures.reduce((acc, curr) => acc.concat((0, _canopycanopycanopy_b_ber_templates_figures.default)({
+		...curr,
+		classes: classes(curr)
+	}, _canopycanopycanopy_b_ber_lib_State.default.build)), _canopycanopycanopy_b_ber_templates_Xhtml.default.loi());
+	const fileName = "figures-titlepage.xhtml";
+	const markup = _canopycanopycanopy_b_ber_lib.Template.render(figuresPage, _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+	const guideItem = new _canopycanopycanopy_b_ber_lib.GuideItem({
+		fileName,
+		title: "Figures",
+		type: "loi"
+	});
+	_canopycanopycanopy_b_ber_lib_State.default.add("guide", guideItem);
+	_canopycanopycanopy_b_ber_logger.default.info(`loi emit figures titlepage [${fileName}]`);
+	return fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.text(fileName), markup, "utf8");
+};
+const createLOIAsSeparateHTMLFiles = () => {
+	const promises = _canopycanopycanopy_b_ber_lib_State.default.figures.map((data) => {
+		const figures = (0, _canopycanopycanopy_b_ber_templates_figures.default)(data, _canopycanopycanopy_b_ber_lib_State.default.build);
+		const markup = _canopycanopycanopy_b_ber_lib.Template.render(figures, _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+		const { page: fileName, ref, pageOrder } = data;
+		const in_toc = false;
+		const buildType = _canopycanopycanopy_b_ber_lib_State.default.build;
+		const spineItem = new _canopycanopycanopy_b_ber_lib.SpineItem({
+			fileName,
+			in_toc,
+			ref,
+			pageOrder,
+			buildType
+		});
+		_canopycanopycanopy_b_ber_lib_State.default.add("loi", spineItem);
+		_canopycanopycanopy_b_ber_logger.default.info(`loi linking [${data.source}] to [${data.page}]`);
+		return fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.text(data.page), markup, "utf8");
+	});
+	return Promise.all(promises).then(() => _canopycanopycanopy_b_ber_lib_State.default.update("loi", (0, lodash_sortBy_js.default)(_canopycanopycanopy_b_ber_lib_State.default.loi, "pageOrder")));
+};
+const loi = () => {
+	if (!_canopycanopycanopy_b_ber_lib_State.default.figures.length) return Promise.resolve();
+	if (_canopycanopycanopy_b_ber_lib_State.default.build === "reader") return createLOIAsSingleHTMLFile().catch(_canopycanopycanopy_b_ber_logger.default.error);
+	return createLOILeader().then(createLOIAsSeparateHTMLFiles).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+//#endregion
+//#region src/mobi/index.ts
+const pageBreakBeforeXPATH = () => [
+	"//h:*[@class=\"figure__large figure__inline\"]",
+	"//h:*[@class=\"figure__large figure__inline\"]/following::h:p[1]",
+	"//h:*[contains(@class, \"break-before\")]",
+	"//h:*[@data-gallery-item]"
+].join("|");
+const mobi = () => process.argv.includes("--no-compile") ? Promise.resolve() : _canopycanopycanopy_b_ber_lib_EbookConvert.default.convert({
+	inputPath: _canopycanopycanopy_b_ber_lib_State.default.dist.ops("content.opf"),
+	outputPath: process.cwd(),
+	fileType: "mobi",
+	fileName: (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("identifier"),
+	flags: [
+		"--mobi-file-type=both",
+		"--disable-font-rescaling",
+		"--no-inline-toc",
+		"--chapter=\"/\"",
+		"--chapter-mark=none",
+		"--disable-remove-fake-margins",
+		`--page-breaks-before='${pageBreakBeforeXPATH()}'`
+	]
+}).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/mobi/mobi-css.ts
+const blackListedPrefixes = ["epub|"];
+const blackListedTypes = ["namespace"];
+const blackListedProperties = [
+	"line-height",
+	"-webkit-hyphens",
+	"-epub-hyphens",
+	"adobe-hyphenate",
+	"-moz-hyphens",
+	"-ms-hyphens",
+	"hyphens",
+	"word-break",
+	"word-break",
+	"widows",
+	"orphans",
+	"text-rendering",
+	"-webkit-font-smoothing",
+	"-moz-osx-font-smoothing",
+	"-webkit-text-fill-color"
+];
+const write$1 = ({ file, content }) => fs_extra.default.writeFile(file, content, "utf8").then(() => _canopycanopycanopy_b_ber_logger.default.info(`mobiCSS write [${path.default.basename(file)}]`));
+const process$1 = (file) => fs_extra.default.readFile(file, "utf8").then((data) => {
+	const ast = css.default.parse(data);
+	let i = ast.stylesheet.rules.length - 1;
+	while (i >= 0) {
+		const rule = ast.stylesheet.rules[i];
+		if (rule.selectors) {
+			let j = rule.selectors.length - 1;
+			while (j >= 0) {
+				let jj = 0;
+				while (jj < blackListedPrefixes.length) {
+					if (rule.selectors[j].slice(0, blackListedPrefixes[jj].length) === blackListedPrefixes[jj]) {
+						_canopycanopycanopy_b_ber_logger.default.info("mobiCSS remove selector", rule.selectors[j]);
+						rule.selectors.splice(j, 1);
+					}
+					jj++;
+				}
+				j--;
+			}
+		}
+		if (blackListedTypes.indexOf(rule.type) > -1) {
+			_canopycanopycanopy_b_ber_logger.default.info(`mobiCSS remove ${rule.type} [${rule[rule.type]}]`);
+			ast.stylesheet.rules.splice(i, 1);
+		}
+		if (ast.stylesheet.rules[i]) {
+			const { declarations } = ast.stylesheet.rules[i];
+			if (declarations) {
+				let a = declarations.length - 1;
+				while (a >= 0) {
+					if (blackListedProperties.indexOf(declarations[a].property) > -1) {
+						_canopycanopycanopy_b_ber_logger.default.info(`mobiCSS remove property [${declarations[a].property}]`);
+						declarations.splice(a, 1);
+					}
+					a--;
+				}
+			}
+		}
+		i--;
+	}
+	return {
+		file,
+		content: css.default.stringify(ast)
+	};
 });
-_Object$defineProperty(exports, "mobiCSS", {
-  enumerable: true,
-  get: function () {
-    return _mobiCss.default;
-  }
+const mobiCSS = () => {
+	const stylesheetsPath = _canopycanopycanopy_b_ber_lib_State.default.dist.stylesheets();
+	return fs_extra.default.readdir(stylesheetsPath).then((files) => Promise.all(files.map((stylesheet) => {
+		const file = _canopycanopycanopy_b_ber_lib_State.default.dist.stylesheets(stylesheet);
+		_canopycanopycanopy_b_ber_logger.default.info(`mobiCSS process [${path.default.basename(file)}]`);
+		return process$1(file).then(write$1);
+	})).catch(_canopycanopycanopy_b_ber_logger.default.error));
+};
+//#endregion
+//#region src/opf/helpers.ts
+const isRemote = (file) => /^http/.test(file);
+const pathInfoFromFile = (file, dest) => {
+	if (isRemote(file)) return {
+		absolutePath: file,
+		opsPath: file,
+		name: file,
+		extension: "",
+		remote: true
+	};
+	return {
+		absolutePath: file,
+		opsPath: (0, _canopycanopycanopy_b_ber_lib_utils.opsPath)(file, dest),
+		name: path.default.basename(file),
+		extension: path.default.extname(file),
+		remote: false
+	};
+};
+const pathInfoFromFiles = (arr, dest) => arr.map((file) => pathInfoFromFile(file, dest));
+//#endregion
+//#region src/opf/ManifestAndMetadata.ts
+var ManifestAndMetadata = class {
+	bookmeta;
+	constructor() {
+		this.bookmeta = [];
+	}
+	async loadMetadata() {
+		this.bookmeta = _canopycanopycanopy_b_ber_lib_State.default.metadata.json();
+	}
+	async createManifestObjectFromAssets() {
+		let files = await (0, recursive_readdir.default)(_canopycanopycanopy_b_ber_lib_State.default.dist.ops());
+		files = [..._canopycanopycanopy_b_ber_lib_State.default.remoteAssets, ...files.filter((file) => path.default.basename(file).charAt(0) !== ".")];
+		return pathInfoFromFiles(files, _canopycanopycanopy_b_ber_lib_State.default.distDir);
+	}
+	createManifestAndMetadataFromTemplates(files) {
+		const manifest = files.map((file) => _canopycanopycanopy_b_ber_templates_Opf_Manifest.default.item(file));
+		const specifiedFonts = (0, lodash_has_js.default)(_canopycanopycanopy_b_ber_lib_State.default.config, "ibooks_specified_fonts") && _canopycanopycanopy_b_ber_lib_State.default.config.ibooks_specified_fonts === true;
+		const modified = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+		const generator = `b-ber@${_canopycanopycanopy_b_ber_lib_State.default.version}`;
+		return {
+			manifest,
+			bookmeta: [
+				...this.bookmeta.map((value) => _canopycanopycanopy_b_ber_templates_Opf_Metadata.default.meta(value)).filter(Boolean),
+				`<meta property="ibooks:specified-fonts">${specifiedFonts}</meta>`,
+				`<meta property="dcterms:modified">${modified}</meta>`,
+				`<meta name="generator" content="${generator}" />`
+			]
+		};
+	}
+	createManifestAndMetadataXML(resp) {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [metadata]");
+		const metadata = (0, layouts.default)(new vinyl.default({
+			path: ".tmp",
+			layout: "body",
+			contents: Buffer.from(resp.bookmeta.join(""))
+		}), { body: _canopycanopycanopy_b_ber_templates_Opf_Metadata.default.body() }).contents?.toString() ?? "";
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [manifest]");
+		return {
+			metadata,
+			manifest: (0, layouts.default)(new vinyl.default({
+				path: ".tmp",
+				layout: "body",
+				contents: Buffer.from(resp.manifest.filter(Boolean).join(""))
+			}), { body: _canopycanopycanopy_b_ber_templates_Opf_Manifest.default.body() }).contents?.toString() ?? ""
+		};
+	}
+	init() {
+		return this.loadMetadata().then(() => this.createManifestObjectFromAssets()).then((resp) => this.createManifestAndMetadataFromTemplates(resp)).then((resp) => this.createManifestAndMetadataXML(resp)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+//#endregion
+//#region src/opf/Navigation.ts
+var Navigation = class Navigation {
+	static createEmptyNavDocuments() {
+		const navDocs = ["toc.ncx", "toc.xhtml"];
+		_canopycanopycanopy_b_ber_logger.default.info(`opf build navigation documents [${navDocs.join(", ")}]`);
+		const promises = navDocs.map((doc) => fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.ops(doc), ""));
+		return Promise.all(promises);
+	}
+	static compareXhtmlWithYaml() {
+		const files = glob.default.sync(_canopycanopycanopy_b_ber_lib_State.default.dist.ops("**", "*.xhtml")).map((file) => path.default.basename(file, ".xhtml"));
+		const promises = [Promise.resolve()];
+		const missing = [];
+		const redundant = [];
+		const tocFile = fs_extra.default.existsSync(_canopycanopycanopy_b_ber_lib_State.default.src.root(`${_canopycanopycanopy_b_ber_lib_State.default.build}.yml`)) ? _canopycanopycanopy_b_ber_lib_State.default.src.root(`${_canopycanopycanopy_b_ber_lib_State.default.build}.yml`) : _canopycanopycanopy_b_ber_lib_State.default.src.root("toc.yml");
+		const tocEntries = _canopycanopycanopy_b_ber_lib_State.default.spine.flattenYAML(_canopycanopycanopy_b_ber_lib.YamlAdaptor.load(tocFile));
+		(0, lodash_difference_js.default)(files, tocEntries).forEach((name) => {
+			if (_canopycanopycanopy_b_ber_lib_State.default.contains("loi", { name })) return;
+			const entry = _canopycanopycanopy_b_ber_lib_State.default.find("spine.flattened", { name });
+			let yamlString = `\n- ${name}`;
+			if (entry) {
+				const { linear, in_toc } = entry;
+				const attributes = {};
+				if (linear === false) attributes.linear = false;
+				if (in_toc === false) attributes.in_toc = false;
+				if (Object.keys(attributes).length) {
+					const space = "\n    ";
+					yamlString += ":";
+					yamlString = Object.entries(attributes).reduce((acc, [key, val]) => acc.concat(`${space}${key}: ${val}`), yamlString);
+				}
+			}
+			missing.push(name);
+			promises.push(fs_extra.default.appendFile(tocFile, yamlString));
+		});
+		const redundantEntries = (0, lodash_difference_js.default)(tocEntries, files);
+		if (_canopycanopycanopy_b_ber_lib_State.default.build === "pdf") {
+			const coverIndex = redundantEntries.indexOf("cover");
+			if (coverIndex > -1) redundantEntries.splice(coverIndex, 1);
+		}
+		redundantEntries.forEach((name) => redundant.push(name));
+		if (missing.length) missing.forEach((name) => _canopycanopycanopy_b_ber_logger.default.warn("opf [%s] was not declared in the TOC. Adding [%s] to [%s]", name, name, path.default.basename(tocFile)));
+		if (redundant.length) {
+			let message = "Files declared in the TOC do not exist in the _markdown directory";
+			message += `\nThe following entries must be removed manually from [${path.default.basename(tocFile)}]:`;
+			message += `\n${redundant.map((name) => `[${name}]`).join("\n")}`;
+			_canopycanopycanopy_b_ber_logger.default.error(message);
+		}
+		return Promise.all(promises);
+	}
+	static async createTocStringsFromTemplate() {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [toc.xhtml]");
+		const { toc } = _canopycanopycanopy_b_ber_lib_State.default;
+		const [{ contents }] = await getFileObjects([{
+			name: "toc.xhtml",
+			data: new vinyl.default({ contents: Buffer.from(_canopycanopycanopy_b_ber_lib.Template.render(_canopycanopycanopy_b_ber_templates_Toc.default.items(toc), _canopycanopycanopy_b_ber_templates_Toc.default.body())) })
+		}]);
+		return contents;
+	}
+	static createNcxStringsFromTemplate() {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [toc.ncx]");
+		const { toc } = _canopycanopycanopy_b_ber_lib_State.default;
+		const ncxXML = _canopycanopycanopy_b_ber_templates_Ncx.default.navPoints(toc);
+		return _canopycanopycanopy_b_ber_lib.Template.render(ncxXML, _canopycanopycanopy_b_ber_templates_Ncx.default.document());
+	}
+	static createGuideStringsFromTemplate() {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [guide]");
+		const guideXML = _canopycanopycanopy_b_ber_templates_Opf_Guide.default.items(_canopycanopycanopy_b_ber_lib_State.default.guide);
+		return _canopycanopycanopy_b_ber_lib.Template.render(guideXML, _canopycanopycanopy_b_ber_templates_Opf_Guide.default.body());
+	}
+	static createSpineStringsFromTemplate() {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [spine]");
+		const { flattened } = _canopycanopycanopy_b_ber_lib_State.default.spine;
+		(0, lodash_remove_js.default)(flattened, (file) => file.generated === true).forEach((file) => {
+			if (!(0, lodash_find_js.default)(flattened, { fileName: file.fileName })) flattened.push(file);
+		});
+		const spineXML = _canopycanopycanopy_b_ber_templates_Opf_Spine.default.items(flattened);
+		return _canopycanopycanopy_b_ber_lib.Template.render(spineXML, _canopycanopycanopy_b_ber_templates_Opf_Spine.default.body());
+	}
+	static writeTocXhtmlFile(toc) {
+		const filepath = _canopycanopycanopy_b_ber_lib_State.default.dist.ops("toc.xhtml");
+		_canopycanopycanopy_b_ber_logger.default.info(`opf emit toc.xhtml [${filepath}]`);
+		return fs_extra.default.writeFile(filepath, toc);
+	}
+	static writeTocNcxFile(ncx) {
+		const filepath = _canopycanopycanopy_b_ber_lib_State.default.dist.ops("toc.ncx");
+		_canopycanopycanopy_b_ber_logger.default.info(`opf emit toc.ncx [${filepath}]`);
+		return fs_extra.default.writeFile(filepath, ncx);
+	}
+	static async writeFiles([toc, ncx, guide, spine]) {
+		await Promise.all([Navigation.writeTocXhtmlFile(toc), Navigation.writeTocNcxFile(ncx)]);
+		return {
+			spine,
+			guide
+		};
+	}
+	static init() {
+		return Navigation.createEmptyNavDocuments().then(() => Navigation.compareXhtmlWithYaml()).then(() => Promise.all([
+			Navigation.createTocStringsFromTemplate(),
+			Navigation.createNcxStringsFromTemplate(),
+			Navigation.createGuideStringsFromTemplate(),
+			Navigation.createSpineStringsFromTemplate()
+		])).then((resp) => Navigation.writeFiles(resp)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+};
+//#endregion
+//#region src/opf/index.ts
+const opf = class Opf {
+	static createOpf() {
+		const manifestAndMetadata = new ManifestAndMetadata();
+		return Promise.all([manifestAndMetadata.init(), Navigation.init()]).then(Opf.createOpfPackageString).then(Opf.writeOPF).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+	static writeOPF(contents) {
+		const opsPath = _canopycanopycanopy_b_ber_lib_State.default.dist.ops("content.opf");
+		_canopycanopycanopy_b_ber_logger.default.info(`opf emit content.opf [${opsPath}]`);
+		return fs_extra.default.writeFile(opsPath, contents);
+	}
+	static createOpfPackageString([manifestAndMetadataXML, navigationXML]) {
+		_canopycanopycanopy_b_ber_logger.default.info("opf build [package]");
+		const { metadata, manifest } = manifestAndMetadataXML;
+		const { guide, spine } = navigationXML;
+		return (0, layouts.default)(new vinyl.default({
+			path: ".tmp",
+			layout: "body",
+			contents: Buffer.from(`
+                        ${metadata}
+                        ${manifest}
+                        ${spine}
+                        ${guide}
+                `)
+		}), { body: _canopycanopycanopy_b_ber_templates_Opf_Pkg.default.body() }).contents?.toString() ?? "";
+	}
+}.createOpf;
+//#endregion
+//#region src/pdf/index.ts
+const booleans = new Set([
+	"pdf_mark_links",
+	"preserve_cover_aspect_ratio",
+	"pretty_print",
+	"uncompressed_pdf",
+	"pdf_page_numbers",
+	"pdf_add_toc",
+	"use_profile_size",
+	"disable_font_rescaling",
+	"subset_embedded_fonts",
+	"embed_all_fonts ",
+	"linearize_tables",
+	"expand_css",
+	"smarten_punctuation",
+	"unsmarten_punctuation",
+	"insert_blank_line",
+	"remove_paragraph_spacing",
+	"asciiize",
+	"keep_ligatures",
+	"enable_heuristics",
+	"disable_markup_chapter_headings",
+	"disable_italicize_common_cases",
+	"disable_fix_indents",
+	"disable_unwrap_lines",
+	"disable_delete_blank_paragraphs",
+	"disable_format_scene_breaks",
+	"disable_dehyphenate",
+	"disable_renumber_headings",
+	"prefer_metadata_cover",
+	"remove_first_image",
+	"insert_metadata ",
+	"disable_remove_fake_margins",
+	"no_chapters_in_toc",
+	"use_auto_toc",
+	"duplicate_links_in_toc"
+]);
+const settings = new Set([
+	"u",
+	"unit",
+	"m",
+	"read_metadata_from_opf",
+	"from_opf",
+	"custom_size",
+	"pdf_standard_font",
+	"pdf_page_margin_top",
+	"pdf_page_margin_right",
+	"toc_title",
+	"pdf_serif_family",
+	"pdf_mono_font_size",
+	"pdf_page_margin_left",
+	"pdf_page_margin_bottom",
+	"pdf_footer_template",
+	"pdf_default_font_size",
+	"pdf_sans_family",
+	"pdf_mono_family",
+	"paper_size",
+	"pdf_header_template",
+	"base_font_size",
+	"font_size_mapping",
+	"embed_font_family",
+	"line_height",
+	"minimum_line_height",
+	"extra_css",
+	"filter_css",
+	"transform_css_rules",
+	"margin_top",
+	"margin_left",
+	"margin_right",
+	"margin_bottom",
+	"change_justification",
+	"insert_blank_line_size",
+	"remove_paragraph_spacing_indent_size",
+	"html_unwrap_factor",
+	"replace_scene_breaks",
+	"sr1_search",
+	"sr1_replace",
+	"sr2_search",
+	"sr2_replace",
+	"sr3_search",
+	"sr3_replace",
+	"search_replace",
+	"chapter",
+	"chapter_mark",
+	"page_breaks_before",
+	"start_reading_at",
+	"level1_toc",
+	"level2_toc",
+	"level3_toc",
+	"toc_threshold",
+	"max_toc_links",
+	"toc_filter",
+	"title",
+	"authors",
+	"title_sort",
+	"author_sort",
+	"cover",
+	"comments",
+	"publisher",
+	"series",
+	"series_index",
+	"rating",
+	"isbn",
+	"tags",
+	"book_producer",
+	"language",
+	"pubdate",
+	"timestamp"
+]);
+const toArg = (key, val) => {
+	if (typeof val === "undefined") return `--${(0, lodash_kebabCase_js.default)(key)}`;
+	return `--${(0, lodash_kebabCase_js.default)(key)}=${val}`;
+};
+const getPDFFlags = (options) => {
+	if (Object.keys(options).length < 1) return [];
+	return Object.entries(options).reduce((acc, [key, val]) => {
+		if (booleans.has(key)) return acc.concat(toArg(key));
+		if (settings.has(key)) return acc.concat(toArg(key, val));
+		return acc;
+	}, []);
+};
+const pdf = () => {
+	const opsPath = _canopycanopycanopy_b_ber_lib_State.default.dist.ops();
+	const inputPath = path.default.join(opsPath, "content.opf");
+	const flags = getPDFFlags(_canopycanopycanopy_b_ber_lib_State.default.config.pdf_options || {});
+	const tocPath = path.default.join(opsPath, "toc.xhtml");
+	return fs_extra.default.remove(tocPath).then(() => process.argv.includes("--no-compile") ? Promise.resolve() : _canopycanopycanopy_b_ber_lib_EbookConvert.default.convert({
+		inputPath,
+		outputPath: process.cwd(),
+		fileType: "pdf",
+		fileName: (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("identifier"),
+		flags
+	}).catch(_canopycanopycanopy_b_ber_logger.default.error));
+};
+//#endregion
+//#region src/reader/index.ts
+var Reader = class {
+	outputDirName;
+	outputDir;
+	apiDir;
+	epubAssets;
+	readerModuleName;
+	readerModuleDistDir;
+	readerAppPath;
+	constructor() {
+		this.outputDirName = "epub";
+		this.outputDir = _canopycanopycanopy_b_ber_lib_State.default.dist.root(this.outputDirName);
+		this.apiDir = _canopycanopycanopy_b_ber_lib_State.default.dist.root("api");
+		this.epubAssets = [
+			"META-INF",
+			"OPS",
+			"mimetype"
+		];
+		this.readerModuleName = "@canopycanopycanopy/b-ber-reader";
+		this.readerModuleDistDir = "dist";
+		this.readerAppPath = null;
+		return this.createOutputDirs().then(() => this.ensureReaderModuleExists()).then(() => this.copyEpubToOutputDir()).then(() => this.writeBookManifest()).then(() => this.writeWebpubManifest()).then(() => this.copyReaderAppToOutputDir()).then(() => this.injectServerDataIntoTemplate()).then(() => this.updateAssetURLsWithAbsolutePaths()).then(() => this.injectWebpubManifestLink()).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	}
+	get remoteURL() {
+		if (process.env.NODE_ENV === "production" && (!_canopycanopycanopy_b_ber_lib_State.default.config || !_canopycanopycanopy_b_ber_lib_State.default.config.remote_url || /^http/.test(_canopycanopycanopy_b_ber_lib_State.default.config.remote_url) === false)) throw new Error("Task [build/reader] requires a remote_url to be set in config.yml");
+		return _canopycanopycanopy_b_ber_lib_State.default.config.remote_url || "http://localhost:4000/";
+	}
+	createDirname(s) {
+		if (!s || typeof s !== "string") return crypto.default.randomBytes(20).toString("hex");
+		return s.replace(/[^0-9a-zA-Z-]/g, "-");
+	}
+	ensureReaderModuleExists() {
+		try {
+			this.readerAppPath = path.default.join(path.default.dirname(path.default.join(require.resolve(this.readerModuleName))), this.readerModuleDistDir);
+			return;
+		} catch (err) {
+			_canopycanopycanopy_b_ber_logger.default.warn(`Could not find globally installed module ${this.readerModuleName}`);
+		}
+		const { paths } = module;
+		let modulePath;
+		for (let i = 0; i < paths.length; i++) {
+			const _path = path.default.resolve(paths[i], this.readerModuleName);
+			if (fs_extra.default.existsSync(_path)) {
+				modulePath = _path;
+				break;
+			}
+		}
+		if (!modulePath) _canopycanopycanopy_b_ber_logger.default.error(`Cannot find module ${this.readerModuleName}. Try running npm i -S ${this.readerModuleName}`);
+		try {
+			this.readerAppPath = fs_extra.default.realpathSync(path.default.join(modulePath, this.readerModuleDistDir));
+			const pkg = fs_extra.default.readJsonSync(path.default.join(modulePath, this.readerModuleDistDir, "package.json"));
+			_canopycanopycanopy_b_ber_logger.default.warn(`Loaded ${this.readerModuleName} v${pkg.version}`);
+			return;
+		} catch (err) {
+			_canopycanopycanopy_b_ber_logger.default.error(`
+                A symlinked version of ${this.readerModuleName} was found but is inaccessible.
+                Try running npm i -S ${this.readerModuleName}, or rebuilding the reader package if running this command in a development environment
+            `);
+			process.exit(1);
+		}
+	}
+	createOutputDirs() {
+		return fs_extra.default.ensureDir(this.outputDir).then(() => fs_extra.default.ensureDir(this.apiDir));
+	}
+	copyEpubToOutputDir() {
+		const epubDir = this.createDirname(this.getBookMetadata("identifier"));
+		const promises = this.epubAssets.map((item) => fs_extra.default.move(_canopycanopycanopy_b_ber_lib_State.default.dist.root(item), path.default.join(this.outputDir, epubDir, item)));
+		return Promise.all(promises);
+	}
+	getBookMetadata(term) {
+		if (!term) return _canopycanopycanopy_b_ber_lib_State.default.metadata.json();
+		const entry = (0, lodash_find_js.default)(_canopycanopycanopy_b_ber_lib_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 "";
+	}
+	getProjectConfig(term) {
+		if (!term) return _canopycanopycanopy_b_ber_lib_State.default.config;
+		if (!(0, lodash_has_js.default)(_canopycanopycanopy_b_ber_lib_State.default.config, term)) _canopycanopycanopy_b_ber_logger.default.warn(`Invalid property for config: ${term}`);
+		return _canopycanopycanopy_b_ber_lib_State.default.config[term];
+	}
+	writeBookManifest() {
+		const id = this.getBookMetadata("identifier");
+		const title = this.getBookMetadata("title");
+		const url = `${_canopycanopycanopy_b_ber_lib.Url.trimSlashes(this.remoteURL)}/${this.outputDirName}/${this.createDirname(id)}`;
+		const cover = `${url}/OPS/images/${this.getBookMetadata("cover")}`;
+		const { downloads, ui_options, layout } = this.getProjectConfig();
+		const manifest = [{
+			title,
+			url,
+			cover,
+			id,
+			downloads,
+			ui_options,
+			layout
+		}];
+		return fs_extra.default.writeJson(path.default.join(this.apiDir, "books.json"), manifest);
+	}
+	writeWebpubManifest() {
+		return (0, recursive_readdir.default)(path.default.join(process.cwd(), this.outputDir, this.getBookMetadata("identifier"), "OPS")).then((files) => {
+			const manifest = (0, _canopycanopycanopy_b_ber_lib_utils.generateWebpubManifest)(files);
+			fs_extra.default.writeJson(_canopycanopycanopy_b_ber_lib_State.default.dist.root("manifest.json"), manifest);
+		});
+	}
+	injectWebpubManifestLink() {
+		const indexHTML = _canopycanopycanopy_b_ber_lib_State.default.dist.root("index.html");
+		const readerURL = _canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(this.getProjectConfig("reader_url"));
+		let contents;
+		contents = fs_extra.default.readFileSync(indexHTML, "utf8");
+		contents = contents.replace(/<\/head>/, `<link rel="manifest" type="application/webpub+json" href="${readerURL}manifest.json"></head>`);
+		return fs_extra.default.writeFile(indexHTML, contents);
+	}
+	copyReaderAppToOutputDir() {
+		const promises = fs_extra.default.readdirSync(this.readerAppPath).map((file) => fs_extra.default.copy(path.default.join(this.readerAppPath, file), path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.dist.root(file))));
+		return Promise.all(promises);
+	}
+	injectServerDataIntoTemplate() {
+		const indexHTML = _canopycanopycanopy_b_ber_lib_State.default.dist.root("index.html");
+		const bookURL = `${_canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(this.getProjectConfig("reader_url"))}epub/${this.getBookMetadata("identifier")}`;
+		const serverData = {
+			books: [{
+				title: this.getBookMetadata("title"),
+				url: bookURL,
+				cover: this.getBookMetadata("cover")
+			}],
+			bookURL,
+			projectURL: _canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(this.getProjectConfig("remote_url")),
+			downloads: this.getProjectConfig("downloads"),
+			basePath: _canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(this.getProjectConfig("base_path")),
+			loadRemoteLibrary: false,
+			uiOptions: this.getProjectConfig("ui_options"),
+			cache: this.getProjectConfig("cache"),
+			layout: this.getProjectConfig("layout")
+		};
+		let contents;
+		contents = fs_extra.default.readFileSync(indexHTML, "utf8");
+		contents = contents.replace(/__SERVER_DATA__ = {}/, `__SERVER_DATA__ = ${JSON.stringify(serverData)}`);
+		return fs_extra.default.writeFile(indexHTML, contents);
+	}
+	updateLinkedResourcesWithAbsolutePaths() {
+		const versionHash = fs_extra.default.readFileSync(_canopycanopycanopy_b_ber_lib_State.default.dist.root("index.html"), "utf8").match(/link href="\/(\w+\.css)"/)?.[1] ?? "";
+		const stylesheet = _canopycanopycanopy_b_ber_lib_State.default.dist.root(versionHash);
+		const readerURL = _canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(this.getProjectConfig("reader_url"));
+		let contents;
+		contents = fs_extra.default.readFileSync(stylesheet, "utf8");
+		contents = contents.replace(/url\(\//g, `url(${readerURL}`);
+		return fs_extra.default.writeFile(stylesheet, contents);
+	}
+	updateAssetURLsWithAbsolutePaths() {
+		const indexHTML = _canopycanopycanopy_b_ber_lib_State.default.dist.root("index.html");
+		const readerURL = _canopycanopycanopy_b_ber_lib.Url.removeTrailingSlash(this.getProjectConfig("reader_url"));
+		let contents;
+		contents = fs_extra.default.readFileSync(indexHTML, "utf8");
+		contents = contents.replace(/(src|href)="(\/[^"]+?)"/g, `$1="${readerURL}$2"`);
+		return fs_extra.default.writeFile(indexHTML, contents);
+	}
+};
+const main$1 = () => new Reader();
+//#endregion
+//#region src/render/index.ts
+const writeMarkupToFile = (fname, markup) => {
+	fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.text(`${fname}.xhtml`), markup).then(() => _canopycanopycanopy_b_ber_logger.default.info(`render xhtml [${path.default.basename(fname)}.xhtml]`));
+};
+const createPageLayout = (fileName, data) => {
+	const textDir = _canopycanopycanopy_b_ber_lib_State.default.dist.text();
+	const body = _canopycanopycanopy_b_ber_markdown_renderer.default.render(fileName, data);
+	const markup = _canopycanopycanopy_b_ber_lib.Template.render(body, _canopycanopycanopy_b_ber_templates_Xhtml.default.body());
+	return fs_extra.default.mkdirp(textDir).then(() => writeMarkupToFile(fileName, markup)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+const createXTHMLFile = (fpath) => fs_extra.default.readFile(fpath, "utf8").then((data) => createPageLayout(path.default.basename(fpath, ".md"), data)).catch(_canopycanopycanopy_b_ber_logger.default.error);
+function render() {
+	const markdownDir = _canopycanopycanopy_b_ber_lib_State.default.src.markdown();
+	return fs_extra.default.readdir(markdownDir).then((files) => {
+		return files.filter((a) => a.charAt(0) !== ".").sort((a, b) => {
+			const fileNameA = path.default.basename(a, ".md");
+			const fileNameB = path.default.basename(b, ".md");
+			const indexA = _canopycanopycanopy_b_ber_lib_State.default.indexOf("spine.flattened", { fileName: fileNameA });
+			const indexB = _canopycanopycanopy_b_ber_lib_State.default.indexOf("spine.flattened", { fileName: fileNameB });
+			return indexA < indexB ? -1 : indexA > indexB ? 1 : 0;
+		}).reduce((acc, curr) => acc.then(() => createXTHMLFile(path.default.join(markdownDir, curr)).then(() => _canopycanopycanopy_b_ber_logger.default.info(`render markdown [${path.default.basename(curr)}]`))), Promise.resolve()).catch(_canopycanopycanopy_b_ber_logger.default.error);
+	});
+}
+//#endregion
+//#region src/sample/index.ts
+const sample = () => Promise.resolve();
+//#endregion
+//#region src/sass/index.ts
+const ASSET_DIRNAMES = ["fonts", "images"];
+const autoprefixerOptions = _canopycanopycanopy_b_ber_lib_State.default.config.autoprefixer_options || {
+	overrideBrowserslist: [
+		"defaults",
+		"> 1%",
+		"not dead",
+		"not IE 11"
+	],
+	flexbox: "no-2009"
+};
+const createSCSSString = () => {
+	const chunks = [];
+	const { theme } = _canopycanopycanopy_b_ber_lib_State.default;
+	const themeName = theme.name;
+	const themeSettingsPath = _canopycanopycanopy_b_ber_lib_State.default.src.stylesheets(themeName, "_settings.scss");
+	const themeOverridesPath = _canopycanopycanopy_b_ber_lib_State.default.src.stylesheets(themeName, "_overrides.scss");
+	const themeStylesPath = theme.entry;
+	if (fs_extra.default.existsSync(themeSettingsPath)) {
+		const variableOverrides = fs_extra.default.readFileSync(themeSettingsPath);
+		_canopycanopycanopy_b_ber_logger.default.info(`sass use overrides [${path.default.basename(themeSettingsPath)}]`);
+		_canopycanopycanopy_b_ber_logger.default.info("sass prepend overrides");
+		chunks.push(variableOverrides);
+	}
+	if (fs_extra.default.existsSync(themeStylesPath)) {
+		const themeStyles = fs_extra.default.readFileSync(themeStylesPath);
+		_canopycanopycanopy_b_ber_logger.default.info(`sass attempt build with [${themeName}] theme`);
+		chunks.push(themeStyles);
+	}
+	if (fs_extra.default.existsSync(themeOverridesPath)) {
+		const styleOverrides = fs_extra.default.readFileSync(themeOverridesPath);
+		_canopycanopycanopy_b_ber_logger.default.info(`sass use user-defined styles [${path.default.basename(themeOverridesPath)}]`);
+		_canopycanopycanopy_b_ber_logger.default.info("sass append user-defined styles");
+		chunks.push(styleOverrides);
+	}
+	if (chunks.length < 1) _canopycanopycanopy_b_ber_logger.default.error("No readable stylesheets were found");
+	return Buffer.concat(chunks);
+};
+const ensureCSSDir = () => fs_extra.default.mkdirp(_canopycanopycanopy_b_ber_lib_State.default.dist.stylesheets());
+const copyThemeAssets = () => {
+	const { theme } = _canopycanopycanopy_b_ber_lib_State.default;
+	const promises = ASSET_DIRNAMES.reduce((acc, curr) => {
+		const themePath = path.default.resolve(path.default.dirname(theme.entry), curr);
+		const srcPath = _canopycanopycanopy_b_ber_lib_State.default.src.root(`_${curr}`);
+		fs_extra.default.mkdirpSync(srcPath);
+		try {
+			fs_extra.default.lstatSync(themePath).isDirectory();
+		} catch (err) {
+			if (err.code === "ENOENT") return acc;
+			throw new Error(`There was a problem copying [${themePath}] to [${srcPath}]`);
+		}
+		const data = fs_extra.default.readdirSync(themePath).filter((a) => a.charAt(0) !== ".").map((fileName) => ({
+			input: path.default.join(themePath, fileName),
+			output: path.default.join(srcPath, fileName)
+		}));
+		return acc.concat(data);
+	}, []).map(({ input, output }) => fs_extra.default.copy(input, output, {
+		overwrite: false,
+		errorOnExist: false
+	}));
+	return Promise.all(promises);
+};
+function resolveImportedModule(importPath) {
+	let importTree = importPath.slice(1).split(path.default.sep);
+	importTree = importTree.filter(Boolean);
+	let moduleScope = "";
+	let moduleName = importTree.shift();
+	if (moduleName[0] === "@") {
+		moduleScope = moduleName;
+		moduleName = importTree.shift();
+	}
+	const moduleNameWithScope = path.default.join(moduleScope, moduleName);
+	const modulePath = require.resolve(moduleNameWithScope, { paths: [path.default.join(path.default.dirname(_canopycanopycanopy_b_ber_lib_State.default.theme.entry))] });
+	if (!importTree.length) return modulePath;
+	const moduleIndex = modulePath.indexOf(moduleName) + moduleName.length;
+	const packagePath = modulePath.slice(0, moduleIndex);
+	return path.default.join(packagePath, ...importTree);
+}
+const renderCSS = (scssString) => new Promise((resolve) => {
+	sass.default.render({
+		importer: (url, _file, done) => {
+			return done({ file: url[0] === "~" ? resolveImportedModule(url) : url });
+		},
+		data: `$build: "${_canopycanopycanopy_b_ber_lib_State.default.build}";${scssString}`,
+		includePaths: [
+			_canopycanopycanopy_b_ber_lib_State.default.src.stylesheets(),
+			path.default.dirname(_canopycanopycanopy_b_ber_lib_State.default.theme.entry),
+			path.default.dirname(path.default.dirname(_canopycanopycanopy_b_ber_lib_State.default.theme.entry))
+		],
+		outputStyle: _canopycanopycanopy_b_ber_lib_State.default.env === "production" ? "compressed" : "expanded",
+		errLogToConsole: true
+	}, (err, result) => {
+		if (err) throw err;
+		resolve(result);
+	});
 });
-_Object$defineProperty(exports, "opf", {
-  enumerable: true,
-  get: function () {
-    return _opf.default;
-  }
+const applyPostProcessing = ({ css }) => (0, postcss.default)((0, autoprefixer.default)(autoprefixerOptions)).process(css, { from: void 0 });
+const writeCSSFile = ({ css }) => {
+	const fileName = _canopycanopycanopy_b_ber_lib_State.default.env === "production" ? `${_canopycanopycanopy_b_ber_lib_State.default.hash}.css` : "application.css";
+	return fs_extra.default.writeFile(_canopycanopycanopy_b_ber_lib_State.default.dist.stylesheets(fileName), css);
+};
+const sass$1 = () => ensureCSSDir().then(copyThemeAssets).then(createSCSSString).then(renderCSS).then(applyPostProcessing).then(writeCSSFile).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/scripts/index.ts
+const uglifyOptions = _canopycanopycanopy_b_ber_lib_State.default.config.uglify_options || { compress: {
+	dead_code: true,
+	conditionals: true,
+	booleans: true
+} };
+const uglify = (contents) => {
+	const result = uglify_js.default.minify(contents, uglifyOptions);
+	if (result.error) throw result.error;
+	if (result.warnings) _canopycanopycanopy_b_ber_logger.default.warn(result.warnings);
+	return result.code;
+};
+const optimized = (files) => {
+	const js = uglify(files.map((file) => fs_extra.default.readFileSync(path.default.resolve(_canopycanopycanopy_b_ber_lib_State.default.src.javascripts(file)), "utf8")).join(""));
+	const { hash } = _canopycanopycanopy_b_ber_lib_State.default;
+	const out = _canopycanopycanopy_b_ber_lib_State.default.dist.javascripts(`${hash}.js`);
+	return fs_extra.default.writeFile(out, js).then(() => _canopycanopycanopy_b_ber_logger.default.info("scripts emit [%s]", `javascripts${path.default.sep}${path.default.basename(out)}`));
+};
+const unoptimized = (files) => {
+	const promises = files.map((file) => {
+		const input = _canopycanopycanopy_b_ber_lib_State.default.src.javascripts(file);
+		const output = _canopycanopycanopy_b_ber_lib_State.default.dist.javascripts(file);
+		return fs_extra.default.copy(input, output).then(() => _canopycanopycanopy_b_ber_logger.default.info("scripts emit [%s]", `javascripts${path.default.sep}${path.default.basename(output)}`));
+	});
+	return Promise.all(promises);
+};
+const write = () => fs_extra.default.readdir(_canopycanopycanopy_b_ber_lib_State.default.src.javascripts()).then((_files) => {
+	const files = _files.filter((a) => path.default.extname(a) === ".js");
+	return (_canopycanopycanopy_b_ber_lib_State.default.env === "production" ? optimized : unoptimized)(files);
 });
-_Object$defineProperty(exports, "pdf", {
-  enumerable: true,
-  get: function () {
-    return _pdf.default;
-  }
-});
-_Object$defineProperty(exports, "reader", {
-  enumerable: true,
-  get: function () {
-    return _reader.default;
-  }
-});
-_Object$defineProperty(exports, "render", {
-  enumerable: true,
-  get: function () {
-    return _render.default;
-  }
-});
-_Object$defineProperty(exports, "sample", {
-  enumerable: true,
-  get: function () {
-    return _sample.default;
-  }
-});
-_Object$defineProperty(exports, "sass", {
-  enumerable: true,
-  get: function () {
-    return _sass.default;
-  }
-});
-_Object$defineProperty(exports, "scripts", {
-  enumerable: true,
-  get: function () {
-    return _scripts.default;
-  }
-});
-_Object$defineProperty(exports, "serialize", {
-  enumerable: true,
-  get: function () {
-    return _serialize.default;
-  }
-});
-_Object$defineProperty(exports, "serve", {
-  enumerable: true,
-  get: function () {
-    return _serve.default;
-  }
-});
-_Object$defineProperty(exports, "validate", {
-  enumerable: true,
-  get: function () {
-    return _validate.default;
-  }
+const ensureDir = () => fs_extra.default.mkdirp(_canopycanopycanopy_b_ber_lib_State.default.dist.javascripts());
+const scripts = () => ensureDir().then(write).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/validate/index.ts
+const validate = async ({ project }) => {
+	const markdownPath = path.default.resolve(process.cwd(), project, _canopycanopycanopy_b_ber_lib_State.default.src.markdown());
+	if (!fs_extra.default.pathExists(markdownPath)) _canopycanopycanopy_b_ber_logger.default.error("Project path does not exist, aborting");
+	const files = (await fs_extra.default.readdir(markdownPath)).filter((f) => f.slice(-2).toLowerCase() === "md").map((f) => path.default.join(markdownPath, f));
+	const errors = [];
+	const check = files.map(async (file) => {
+		const res = (0, _canopycanopycanopy_b_ber_validator.default)({
+			text: await fs_extra.default.readFile(file, "utf8"),
+			index: 0
+		});
+		if (res.success === false) {
+			(0, _canopycanopycanopy_b_ber_validator.report)(path.default.basename(file), res);
+			errors.push(res);
+		} else _canopycanopycanopy_b_ber_logger.default.info("Syntax valid %s", path.default.basename(file));
+	});
+	await Promise.all(check);
+	if (!errors.length) _canopycanopycanopy_b_ber_logger.default.info("Directives valid");
+	_canopycanopycanopy_b_ber_logger.default.info(errors);
+};
+//#endregion
+//#region src/web/Template.ts
+var Template = class {
+	static header(title) {
+		return `
+      <header class="publication__header" role="navigation">
+        <div class="header__item header__item__toggle header__item__toggle--toc">
+          <button class="material-icons">view_list</button>
+        </div>
+
+        <div class="header__item header__item__title">
+          <h1>${title}</h1>
+        </div>
+
+        <div class="header__item publication__search">
+          <button class="material-icons publication__search__button publication__search__button--open">search</button>
+          <input type="text" disabled="disabled" class="publication__search__input" placeholder="" name="s" value="" />
+          <button class="material-icons publication__search__button publication__search__button--close">close</button>
+        </div>
+
+        <div class="header__item header__item__toggle header__item__toggle--info">
+          <button class="material-icons">info</button>
+        </div>
+      </header>
+    `;
+	}
+	static metadata(data) {
+		return `
+      <dl>
+        ${data.reduce((acc, curr) => acc.concat(`
+              <dt>${curr.term}</dt>
+              <dd>${curr.value}</dd>
+            `), "")}
+      </dl>
+    `;
+	}
+	static toc(baseURL, title, content) {
+		return `
+      <nav class="publication__toc" role="navigation">
+        <div class="publication__title">
+          <a href="${baseURL}">${title}</a>
+        </div>
+        ${content}
+      </nav>
+    `;
+	}
+	static info(content) {
+		return `
+      <nav class="publication__info" role="navigation">
+        ${content}
+      </nav>
+    `;
+	}
+	static prev(baseURL, href) {
+		return `
+      <div class="publication__nav__prev">
+        <a class="publication__nav__link" href="${baseURL}text/${href}">
+          <i class="material-icons">arrow_back</i>
+        </a>
+      </div>
+    `;
+	}
+	static next(baseURL, href) {
+		return `
+      <div class="publication__nav__next">
+        <a class="publication__nav__link" href="${baseURL}text/${href}">
+          <i class="material-icons">arrow_forward</i>
+        </a>
+      </div>
+    `;
+	}
+	static pagination(prev, next) {
+		return `
+      <nav class="publication__nav" role="navigation">
+        ${prev}
+        ${next}
+      </nav>
+    `;
+	}
+	static styles() {
+		return `
+      <style>
+        body { opacity: 0; transition: opacity 250ms ease; }
+        body.ready { opacity: 1 !important; }
+      </style>
+    `;
+	}
+	static scripts(content) {
+		return `
+      <script type="text/javascript">
+      // <![CDATA[
+      ${content}
+      // ]]>
+      <\/script>
+    `;
+	}
+	static cover(firstPage, coverImageSrc) {
+		return `
+      <a class="cover__image__link" href="${firstPage}">
+        <img class="cover__image" src="${coverImageSrc}" alt="Cover" />
+      </a>
+    `;
+	}
+	static robots(isPrivate) {
+		return isPrivate ? "<meta name=\"robots\" content=\"noindex,nofollow\"/>" : "<meta name=\"robots\" content=\"index,follow\"/>";
+	}
+	static body(styleBlock, headerElement) {
+		return `
+      <body style="opacity: 0;">
+      ${styleBlock}
+      <div class="publication">
+      ${headerElement}
+      <div class="publication__contents">
+    `;
+	}
+	static footer(pageNavigation, tocElement, infoElement, navigationToggleScript, webWorkerScript, evenHandlerScript) {
+		return `
+      </div> <!-- / .publication__contents -->
+      ${pageNavigation}
+      </div> <!-- / .publication -->
+      ${tocElement}
+      ${infoElement}
+      ${navigationToggleScript}
+      ${webWorkerScript}
+      ${evenHandlerScript}
+      $1
+    `;
+	}
+	static index(baseURL, robotsMeta, title, styleBlock, tocElement, infoElement, headerElement, coverImage, navigationToggleScript, webWorkerScript) {
+		return `
+      <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+      <html xmlns="http://www.w3.org/1999/xhtml"
+        xmlns:epub="http://www.idpf.org/2007/ops"
+        xmlns:ibooks="http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0"
+        epub:prefix="ibooks: http://vocabulary.itunes.apple.com/rdf/ibooks/vocabulary-extensions-1.0">
+        <meta http-equiv="default-style" content="text/html charset=utf-8"/>
+        ${robotsMeta}
+        <link rel="manifest" type="application/webpub+json" href="${baseURL}manifest.json">
+        <link rel="stylesheet" type="text/css" href="${baseURL}stylesheets/application.css"/>
+
+        <head>
+          <title>${title}</title>
+          ${styleBlock}
+        </head>
+        <body style="opacity: 0;">
+          ${tocElement}
+          ${infoElement}
+          <div class="publication">
+            ${headerElement}
+            <div class="publication__contents">
+              <section>
+                ${coverImage}
+              </section>
+            </div>
+          </div>
+          ${navigationToggleScript}
+          ${webWorkerScript}
+        </body>
+      </html>
+    `;
+	}
+};
+//#endregion
+//#region src/web/index.ts
+let ASSETS_TO_UNLINK;
+let DIST_PATH;
+let OPS_PATH;
+let OMIT_FROM_SEARCH;
+let BASE_URL;
+let flow;
+var WebFlow = class {
+	spine;
+	loi;
+	constructor({ spine, loi }) {
+		this.spine = spine;
+		this.loi = loi;
+		this.prepareLoi();
+		this.addFiguresToSpine();
+		this.removeNonLinearEntriesFromSpine();
+		this.removeTocFromSpine();
+	}
+	prepareLoi() {
+		this.loi = this.loi.map((a) => {
+			const b = { ...a };
+			b.fileName = b.fileName.replace(/\.xhtml$/, "");
+			b.relativePath = b.relativePath.replace(/\.xhtml$/, "");
+			return b;
+		});
+	}
+	getFiguresPageIndex() {
+		return (0, lodash_findIndex_js.default)(this.spine.flattened, { fileName: "figures-titlepage" });
+	}
+	addFiguresToSpine() {
+		if (!this.loi.length) return;
+		const figuresPageIndex = this.getFiguresPageIndex();
+		if (figuresPageIndex < 0) return;
+		this.spine.flattened.splice(figuresPageIndex + 1, 0, ...this.loi);
+	}
+	removeNonLinearEntriesFromSpine() {
+		this.spine = this.spine.flattened.filter((a) => a.linear);
+	}
+	removeTocFromSpine() {
+		this.spine = this.spine.filter((a) => a.fileName !== "toc");
+	}
+};
+async function initialize() {
+	DIST_PATH = _canopycanopycanopy_b_ber_lib_State.default.distDir;
+	OPS_PATH = path.default.join(DIST_PATH, "OPS");
+	BASE_URL = _canopycanopycanopy_b_ber_lib.Url.addTrailingSlash(_canopycanopycanopy_b_ber_lib_State.default.config.base_url);
+	ASSETS_TO_UNLINK = [
+		path.default.join(DIST_PATH, "mimetype"),
+		path.default.join(DIST_PATH, "META-INF"),
+		path.default.join(DIST_PATH, "OPS/content.opf"),
+		path.default.join(DIST_PATH, "OPS/toc.ncx")
+	];
+	OMIT_FROM_SEARCH = ["toc"];
+	const { spine, loi } = _canopycanopycanopy_b_ber_lib_State.default;
+	flow = new WebFlow({
+		spine,
+		loi
+	});
+}
+async function moveAssetsToRootDirctory() {
+	const promises = fs_extra.default.readdirSync(OPS_PATH).filter((file) => file.charAt(0) !== "." && fs_extra.default.statSync(path.default.join(OPS_PATH, file)).isDirectory()).map((dir) => {
+		const from = path.default.join(OPS_PATH, dir);
+		const to = path.default.join(DIST_PATH, dir);
+		_canopycanopycanopy_b_ber_logger.default.info("Moving [%s]", dir);
+		return fs_extra.default.move(from, to);
+	});
+	await Promise.all(promises);
+	return fs_extra.default.remove(OPS_PATH);
+}
+function unlinkRedundantAssets() {
+	const promises = ASSETS_TO_UNLINK.map((file) => {
+		_canopycanopycanopy_b_ber_logger.default.info("Removing [%s]", path.default.basename(file));
+		return fs_extra.default.remove(file);
+	});
+	return Promise.all(promises);
+}
+function getProjectTitle() {
+	let title = "";
+	const titleEntry = (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("title");
+	if (titleEntry) title = titleEntry;
+	return title;
+}
+function getChapterTitle(fileName) {
+	if (typeof fileName !== "string") return getProjectTitle();
+	const meta = _canopycanopycanopy_b_ber_lib_State.default.spine.frontMatter.get(fileName);
+	if (!meta?.title) return getProjectTitle();
+	return meta.title;
+}
+function getProjectMetadataHTML() {
+	return Template.metadata(_canopycanopycanopy_b_ber_lib_State.default.metadata.json());
+}
+function getHeaderElement(fileName) {
+	const title = getChapterTitle(fileName) ?? "";
+	return Template.header(title);
+}
+function createNavigationElement() {
+	const { toc: prevToc } = _canopycanopycanopy_b_ber_lib_State.default;
+	const toc = prevToc.filter((item) => item.fileName !== "toc");
+	const tocHTML = _canopycanopycanopy_b_ber_templates_Toc.default.items(toc).replace(/a href="/g, `a href="${BASE_URL}`);
+	const metadataHTML = getProjectMetadataHTML();
+	const title = getProjectTitle();
+	return {
+		tocElement: Template.toc(BASE_URL, title, tocHTML),
+		infoElement: Template.info(metadataHTML)
+	};
+}
+function buttonPrev(filePath) {
+	const fileName = path.default.basename(filePath, ".xhtml");
+	const index = (0, lodash_findIndex_js.default)(flow.spine, { fileName });
+	const prevIndex = index - 1;
+	let html = "";
+	if (index > -1 && flow.spine[prevIndex]) {
+		const href = `${flow.spine[prevIndex].fileName}.xhtml`;
+		html = Template.prev(BASE_URL, href);
+	}
+	return html;
+}
+function buttonNext(filePath) {
+	const fileName = path.default.basename(filePath, ".xhtml");
+	const index = (0, lodash_findIndex_js.default)(flow.spine, { fileName });
+	const nextIndex = index + 1;
+	let html = "";
+	if (index > -1 && flow.spine[nextIndex]) {
+		const href = `${flow.spine[nextIndex].fileName}.xhtml`;
+		html = Template.next(BASE_URL, href);
+	}
+	return html;
+}
+function paginate(filePath) {
+	return {
+		prev: buttonPrev(filePath),
+		next: buttonNext(filePath)
+	};
+}
+function paginationNavigation(filePath) {
+	const { prev, next } = paginate(filePath);
+	return Template.pagination(prev, next);
+}
+function injectBaseURL(script) {
+	const script_ = typeof script === "string" ? script : String(script);
+	return Buffer.from(script_.replace(/%BASE_URL%/g, BASE_URL));
+}
+function getStyleBlock() {
+	return Template.styles();
+}
+function getNavigationToggleScript() {
+	const content = injectBaseURL(fs_extra.default.readFileSync(path.default.join(__dirname, "navigation.js")));
+	return Template.scripts(content);
+}
+function getWebWorkerScript() {
+	const content = injectBaseURL(fs_extra.default.readFileSync(path.default.join(__dirname, "search.js")));
+	return Template.scripts(content);
+}
+function getEventHandlerScript() {
+	const content = injectBaseURL(fs_extra.default.readFileSync(path.default.join(__dirname, "event-handlers.js")));
+	return Template.scripts(content);
+}
+function injectPageElementsIntoFile(filePath) {
+	const { tocElement, infoElement } = createNavigationElement();
+	const pageNavigation = paginationNavigation(filePath);
+	const styleBlock = getStyleBlock();
+	const navigationToggleScript = getNavigationToggleScript();
+	const webWorkerScript = getWebWorkerScript();
+	const evenHandlerScript = getEventHandlerScript();
+	const headerElement = getHeaderElement(path.default.basename(filePath, path.default.extname(filePath)));
+	_canopycanopycanopy_b_ber_logger.default.info(`Adding pagination to ${path.default.basename(filePath)}`);
+	const data = fs_extra.default.readFileSync(filePath, "utf8");
+	let contents;
+	contents = data.replace(/(<body[^>]*?>)/, Template.body(styleBlock, headerElement));
+	contents = contents.replace(/(<\/body>)/, Template.footer(pageNavigation, tocElement, infoElement, navigationToggleScript, webWorkerScript, evenHandlerScript));
+	_canopycanopycanopy_b_ber_logger.default.info(`web writing ${path.default.basename(filePath)}`);
+	return fs_extra.default.writeFile(filePath, contents);
+}
+function injectPageElementsIntoFiles(elements) {
+	const textPath = path.default.join(DIST_PATH, "text");
+	const promises = fs_extra.default.readdirSync(textPath).filter((file) => path.default.extname(file) === ".xhtml").map((file) => {
+		return injectPageElementsIntoFile(path.default.resolve(textPath, file));
+	});
+	return Promise.all(promises).then(() => elements);
+}
+function indexPageContent() {
+	const { spine } = flow;
+	const records = [];
+	let fileIndex = -1;
+	const promises = spine.filter((a) => OMIT_FROM_SEARCH.indexOf(a.fileName) < 0).map((entry) => fs_extra.default.readFile(path.default.join(OPS_PATH, `${entry.relativePath}.xhtml`), "utf8").then((data) => {
+		const $ = cheerio.default.load(data);
+		const title = $("h1,h2,h3,h4,h5,h6").first().text();
+		const body = $("body").text();
+		const url = `${BASE_URL}text/${entry.fileName}.xhtml`;
+		fileIndex += 1;
+		records.push({
+			id: fileIndex,
+			title,
+			body,
+			url
+		});
+	}));
+	return Promise.all(promises).then(() => JSON.stringify(records));
+}
+function writeJSONPageData(json) {
+	return fs_extra.default.writeFile(path.default.join(DIST_PATH, "search-index.json"), json);
+}
+function importVendorScripts() {
+	const lunrPath = require.resolve("lunr");
+	const outputPath = path.default.join(DIST_PATH, "lunr.js");
+	return fs_extra.default.copy(lunrPath, outputPath);
+}
+function writeWebWorker() {
+	const worker = injectBaseURL(fs_extra.default.readFileSync(path.default.join(__dirname, "worker.js")));
+	return fs_extra.default.writeFile(path.default.join(DIST_PATH, "worker.js"), worker);
+}
+function writeWebpubManifest() {
+	return new Promise((resolve, reject) => {
+		(0, recursive_readdir.default)(_canopycanopycanopy_b_ber_lib_State.default.distDir, (err1, files) => {
+			if (err1) reject(err1);
+			const manifest = (0, _canopycanopycanopy_b_ber_lib_utils.generateWebpubManifest)(files);
+			fs_extra.default.writeJson(path.default.join(DIST_PATH, "manifest.json"), manifest).then(resolve);
+		});
+	});
+}
+function getPage(_n = -1) {
+	const n = _n - 1;
+	return `${BASE_URL}text/${flow.spine[n].fileName}.xhtml`;
+}
+function getFirstPage() {
+	return getPage(1);
+}
+function getCoverImage() {
+	const coverEntry = (0, lodash_find_js.default)(_canopycanopycanopy_b_ber_lib_State.default.metadata.json(), { term: "cover" });
+	const firstPage = getFirstPage();
+	let coverImageSrc = "images/";
+	if (coverEntry && (0, lodash_has_js.default)(coverEntry, "value")) coverImageSrc += coverEntry.value;
+	return Template.cover(firstPage, coverImageSrc);
+}
+function createIndexHTML() {
+	const { tocElement, infoElement } = createNavigationElement();
+	const title = getProjectTitle();
+	const coverImage = getCoverImage();
+	const navigationToggleScript = getNavigationToggleScript();
+	const webWorkerScript = getWebWorkerScript();
+	const headerElement = getHeaderElement();
+	const styleBlock = getStyleBlock();
+	const robotsMeta = Template.robots(_canopycanopycanopy_b_ber_lib_State.default.config.private);
+	const indexHTML = Template.index(BASE_URL, robotsMeta, title, styleBlock, tocElement, infoElement, headerElement, coverImage, navigationToggleScript, webWorkerScript);
+	return fs_extra.default.writeFile(path.default.resolve(DIST_PATH, "index.html"), indexHTML);
+}
+const web = () => initialize().then(unlinkRedundantAssets).then(indexPageContent).then(writeJSONPageData).then(moveAssetsToRootDirctory).then(injectPageElementsIntoFiles).then(createIndexHTML).then(importVendorScripts).then(writeWebpubManifest).then(writeWebWorker).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/xml/index.ts
+const fileExtension = ".xhtml";
+const writeXML = (str) => {
+	const cwd = process.cwd();
+	const uuid = (0, _canopycanopycanopy_b_ber_lib_utils.getBookMetadata)("identifier");
+	const filePath = path.default.join(cwd, `${uuid}.xml`);
+	return fs_extra.default.writeFile(filePath, str, "utf8");
+};
+const parseHTMLFiles = (files) => new Promise((resolve) => {
+	new _canopycanopycanopy_b_ber_lib_HtmlToXml.default({
+		content: files.reduce((acc, curr) => {
+			const filePath = (0, lodash_isPlainObject_js.default)(curr) ? Object.keys(curr)[0] : (0, lodash_isString_js.default)(curr) ? curr : null;
+			if (!filePath) return acc;
+			const data = fs_extra.default.readFileSync(filePath, "utf8");
+			return acc.concat(`${data}`);
+		}, []).join("<pagebreak></pagebreak>"),
+		onEndCallback: resolve
+	}).parse();
 });
-_Object$defineProperty(exports, "web", {
-  enumerable: true,
-  get: function () {
-    return _web.default;
-  }
+const xml = () => {
+	const spineFiles = [..._canopycanopycanopy_b_ber_lib_State.default.spine.flattened];
+	const figuresTitlePageIndex = (0, lodash_findIndex_js.default)(spineFiles, { fileName: "figures-titlepage" });
+	const files = spineFiles.map((entry) => `${entry.absolutePath}${fileExtension}`);
+	if (figuresTitlePageIndex > -1 && _canopycanopycanopy_b_ber_lib_State.default.loi.length) {
+		const loi = _canopycanopycanopy_b_ber_lib_State.default.loi.map((entry) => entry.absolutePath);
+		files.splice(figuresTitlePageIndex + 1, 0, ...loi);
+	}
+	return parseHTMLFiles(files).then(writeXML).catch(_canopycanopycanopy_b_ber_logger.default.error);
+};
+//#endregion
+//#region src/task-handlers.ts
+var task_handlers_exports = /* @__PURE__ */ __exportAll({
+	clean: () => clean_default,
+	container: () => container_default,
+	copy: () => copy,
+	cover: () => cover_default,
+	deploy: () => main,
+	epub: () => epub,
+	footnotes: () => footnotes_default,
+	generate: () => generate,
+	init: () => Initializer,
+	inject: () => inject,
+	loi: () => loi,
+	mobi: () => mobi,
+	mobiCSS: () => mobiCSS,
+	opf: () => opf,
+	pdf: () => pdf,
+	reader: () => main$1,
+	render: () => render,
+	sample: () => sample,
+	sass: () => sass$1,
+	scripts: () => scripts,
+	validate: () => validate,
+	web: () => web,
+	xml: () => xml
 });
-_Object$defineProperty(exports, "xml", {
-  enumerable: true,
-  get: function () {
-    return _xml.default;
-  }
+//#endregion
+//#region src/serialize.ts
+function validate$1(fn) {
+	if (typeof fn !== "function") throw new Error(`async#serialize: Invalid parameter [${fn}] is [${typeof fn}], expected [function]`);
+}
+const done = (resp) => {
+	_canopycanopycanopy_b_ber_logger.default.notify("done", { state: _canopycanopycanopy_b_ber_lib_State.default });
+	return resp;
+};
+const taskReducer = (acc, curr) => {
+	const fn = (typeof curr === "string" ? task_handlers_exports[curr] : curr) ?? curr;
+	validate$1(fn);
+	return acc.then((resp) => {
+		_canopycanopycanopy_b_ber_logger.default.notify("start", curr);
+		return fn(resp).then((resp2) => {
+			_canopycanopycanopy_b_ber_logger.default.notify("stop", curr);
+			return resp2;
+		});
+	});
+};
+const serialize = (sequence) => sequence.reduce(taskReducer, Promise.resolve(void 0)).then(done).catch(_canopycanopycanopy_b_ber_logger.default.error);
+//#endregion
+//#region src/serve/index.ts
+const browserSync = (0, browser_sync.create)();
+const port = 4e3;
+const debounceSpeed = 500;
+const config = (build) => (url) => () => {
+	_canopycanopycanopy_b_ber_lib_State.default.update("build", build);
+	_canopycanopycanopy_b_ber_lib_State.default.update("footnotes", []);
+	_canopycanopycanopy_b_ber_lib_State.default.update("config.base_url", "/");
+	_canopycanopycanopy_b_ber_lib_State.default.update("config.base_path", "/");
+	_canopycanopycanopy_b_ber_lib_State.default.update("config.remote_url", url);
+	_canopycanopycanopy_b_ber_lib_State.default.update("config.reader_url", url);
+	return serialize(_canopycanopycanopy_b_ber_shapes_sequences_sequences.default[build]);
+};
+let update = async () => {};
+const reload = () => update().then(() => browserSync.reload());
+const browserSyncPlugins = [{
+	module: "bs-html-injector",
+	options: { files: [{
+		match: [
+			path.default.resolve("_project", "**", "*.scss"),
+			path.default.resolve("_project", "**", "*.js"),
+			path.default.resolve("_project", "**", "*.md")
+		],
+		fn: (0, lodash_debounce_js.default)(() => reload(), debounceSpeed, {
+			leading: false,
+			trailing: true
+		})
+	}] }
+}];
+const browserSyncMiddleware = (req, res, next) => {
+	if (/\.xhtml$/.test(req.url)) res.setHeader("Content-Type", "text/html; charset=UTF-8");
+	next();
+};
+const init = (build) => new Promise((resolve) => {
+	const options = {
+		port,
+		open: false,
+		server: {
+			baseDir: path.default.resolve(`project-${build}`),
+			middleware: browserSyncMiddleware
+		},
+		plugins: browserSyncPlugins
+	};
+	browserSync.init(options, () => resolve());
 });
-var _clean = _interopRequireDefault(require("./clean"));
-var _container = _interopRequireDefault(require("./container"));
-var _copy = _interopRequireDefault(require("./copy"));
-var _cover = _interopRequireDefault(require("./cover"));
-var _deploy = _interopRequireDefault(require("./deploy"));
-var _epub = _interopRequireDefault(require("./epub"));
-var _footnotes = _interopRequireDefault(require("./footnotes"));
-var _generate = _interopRequireDefault(require("./generate"));
-var _init = _interopRequireDefault(require("./init"));
-var _inject = _interopRequireDefault(require("./inject"));
-var _loi = _interopRequireDefault(require("./loi"));
-var _mobi = _interopRequireDefault(require("./mobi"));
-var _mobiCss = _interopRequireDefault(require("./mobi/mobi-css"));
-var _opf = _interopRequireDefault(require("./opf"));
-var _pdf = _interopRequireDefault(require("./pdf"));
-var _render = _interopRequireDefault(require("./render"));
-var _sample = _interopRequireDefault(require("./sample"));
-var _sass = _interopRequireDefault(require("./sass"));
-var _scripts = _interopRequireDefault(require("./scripts"));
-var _serve = _interopRequireDefault(require("./serve"));
-var _web = _interopRequireDefault(require("./web"));
-var _xml = _interopRequireDefault(require("./xml"));
-var _serialize = _interopRequireDefault(require("./serialize"));
-var _reader = _interopRequireDefault(require("./reader"));
-var _validate = _interopRequireDefault(require("./validate"));
+const serve = async ({ build: buildOption, external }) => {
+	const location = external ? "external" : "local";
+	const build = buildOption || "reader";
+	await init(build);
+	const url = browserSync.getOption("urls").get(location);
+	update = config(build)(url);
+	await update();
+	const bs = browserSync;
+	bs.instance.setOption("open", location);
+	bs.instance.utils.openBrowser(url, bs.instance.options, bs.instance);
+};
+//#endregion
+exports.clean = clean_default;
+exports.container = container_default;
+exports.copy = copy;
+exports.cover = cover_default;
+exports.deploy = main;
+exports.epub = epub;
+exports.footnotes = footnotes_default;
+exports.generate = generate;
+exports.init = Initializer;
+exports.inject = inject;
+exports.loi = loi;
+exports.mobi = mobi;
+exports.mobiCSS = mobiCSS;
+exports.opf = opf;
+exports.pdf = pdf;
+exports.reader = main$1;
+exports.render = render;
+exports.sample = sample;
+exports.sass = sass$1;
+exports.scripts = scripts;
+exports.serialize = serialize;
+exports.serve = serve;
+exports.validate = validate;
+exports.web = web;
+exports.xml = xml;