hexo-adsense 1.0.26 → 2.0.0

package/dist/index.mjs

@@ -0,0 +1,740 @@
+// hexo-adsense 2.0.0 by Dimas Lanjaka <dimaslanjaka@gmail.com> (https://github.com/dimaslanjaka)
+
+// import nodeUrl from 'node:url';
+// import nodePath from 'path';
+// const __filename = nodeUrl.fileURLToPath(import.meta.url);
+// const __dirname = nodePath.dirname(__filename);
+import fs$2 from 'fs-extra';
+import assign from 'object-assign';
+import path from 'path';
+import * as prettier from 'prettier';
+import { fileURLToPath } from 'url';
+import { globSync } from 'glob';
+import fs$1 from 'hexo-fs';
+import fs from 'fs';
+import require$$1 from 'hexo-log';
+import require$$3 from 'util';
+import { minimatch } from 'minimatch';
+import { memoize } from 'underscore';
+import minimist from 'minimist';
+import ansiColors from 'ansi-colors';
+import { debug, normalizePath, normalizePathUnix } from 'sbg-utility';
+import 'bluebird';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var src = {};
+
+var name = "hexo-is";
+var version = "2.0.0";
+var description = "Determine whether hexo is";
+var main = "dist/index.js";
+var types = "dist/index.d.ts";
+var type = "module";
+var module = "dist/index.mjs";
+var exports = {
+	".": {
+		require: {
+			"default": "./dist/index.cjs",
+			types: "./dist/index.d.ts"
+		},
+		"import": {
+			"default": "./dist/index.mjs",
+			types: "./dist/index.d.mts"
+		}
+	}
+};
+var files = [
+	"dist/"
+];
+var scripts = {
+	test: "echo \"Error: no test specified\" && exit 1",
+	build: "tsc && rollup -c",
+	clean: "rimraf dist && npm run build",
+	hook: "ts-node hook.ts",
+	postbuild: "node packer.js",
+	update: "npx npm-check-updates -u -x chalk",
+	pack: "node packer.cjs --yarn"
+};
+var keywords = [
+];
+var repository = {
+	type: "git",
+	url: "https://github.com/dimaslanjaka/hexo-is.git"
+};
+var homepage = "https://github.com/dimaslanjaka/hexo-seo/tree/master/packages/hexo-is#readme";
+var author = {
+	email: "dimaslanjaka@gmail.com",
+	name: "Dimas Lanjaka",
+	url: "https://github.com/dimaslanjaka"
+};
+var license = "MIT";
+var workspaces = [
+	"test/demo",
+	"test/demo/themes/*"
+];
+var dependencies = {
+	"fs-extra": "^11.2.0",
+	"hexo-log": "^4.1.0",
+	minimatch: "^10.0.1",
+	"sbg-utility": "^2.0.5",
+	upath: "^2.0.1"
+};
+var devDependencies = {
+	"@rollup/plugin-commonjs": "^28.0.1",
+	"@rollup/plugin-json": "^6.1.0",
+	"@rollup/plugin-node-resolve": "^15.3.0",
+	"@types/gulp": "^4.0.17",
+	"@types/node": "^22.8.4",
+	"cross-spawn": "https://github.com/dimaslanjaka/node-cross-spawn/raw/private/release/cross-spawn.tgz",
+	"git-command-helper": "^2.0.2",
+	gulp: "^5.0.0",
+	"gulp-cli": "^3.0.0",
+	hexo: "^7.3.0",
+	nodemon: "^3.1.7",
+	rimraf: "^6.0.1",
+	rollup: "^4.24.3",
+	"rollup-plugin-dts": "^6.1.1",
+	"ts-node": "^10.9.2",
+	typescript: "^5.6.3"
+};
+var resolutions = {
+	"@types/git-command-helper": "https://github.com/dimaslanjaka/git-command-helper/raw/pre-release/release/git-command-helper.tgz",
+	"@types/hexo": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo.tgz",
+	"binary-collections": "https://github.com/dimaslanjaka/bin/raw/fcd1121/releases/bin.tgz",
+	"cross-spawn": "https://github.com/dimaslanjaka/node-cross-spawn/raw/private/release/cross-spawn.tgz",
+	"git-command-helper": "https://github.com/dimaslanjaka/git-command-helper/raw/pre-release/release/git-command-helper.tgz",
+	hexo: "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo.tgz",
+	"hexo-asset-link": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-asset-link.tgz",
+	"hexo-cli": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-cli.tgz",
+	"hexo-front-matter": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-front-matter.tgz",
+	"hexo-generator-redirect": "https://github.com/dimaslanjaka/hexo-generator-redirect/raw/0885394/release/hexo-generator-redirect.tgz",
+	"hexo-log": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-log.tgz",
+	"hexo-post-parser": "https://github.com/dimaslanjaka/hexo-post-parser/raw/8c4e98159e4407b77e1c25e028c1fd4a0073a8e3/release/hexo-post-parser.tgz",
+	"hexo-renderers": "https://github.com/dimaslanjaka/hexo-renderers/raw/add4a2491075dd85281a5dc0c48b74a7ce51d987/release/hexo-renderers.tgz",
+	"hexo-seo": "https://github.com/dimaslanjaka/hexo-seo/raw/f4cf27fbc7de2b831462d3b26cf70ece2499d15b/release/hexo-seo.tgz",
+	"hexo-server": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-server.tgz",
+	"hexo-shortcodes": "https://github.com/dimaslanjaka/hexo-shortcodes/raw/f70a1c0/release/hexo-shortcodes.tgz",
+	"hexo-util": "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/hexo-util.tgz",
+	"instant-indexing": "https://github.com/dimaslanjaka/static-blog-generator/raw/master/packages/instant-indexing/release/instant-indexing.tgz",
+	"markdown-it": "https://github.com/dimaslanjaka/markdown-it/raw/17ccc825cbb3e4c6d59edada5f6d93f27075d752/release/markdown-it.tgz",
+	"nodejs-package-types": "https://github.com/dimaslanjaka/nodejs-package-types/raw/a2e797bc27975cba20ef4c87547841e6341bfcf4/release/nodejs-package-types.tgz",
+	"sbg-api": "https://github.com/dimaslanjaka/static-blog-generator/raw/74a402210be05e3452a386f90b80521e1182a724/packages/sbg-api/release/sbg-api.tgz",
+	"sbg-cli": "https://github.com/dimaslanjaka/static-blog-generator/raw/0164b0d2e4ba5453890af8ec4863b2a09e043815/packages/sbg-cli/release/sbg-cli.tgz",
+	"sbg-server": "https://github.com/dimaslanjaka/static-blog-generator/raw/master/packages/sbg-server/release/sbg-server.tgz",
+	"sbg-utility": "https://github.com/dimaslanjaka/static-blog-generator/raw/c7e82cae850b9fd6c1829ff6d30ef3ee8987019b/packages/sbg-utility/release/sbg-utility.tgz",
+	"static-blog-generator": "https://github.com/dimaslanjaka/static-blog-generator/raw/master/packages/static-blog-generator/release/static-blog-generator.tgz",
+	warehouse: "https://github.com/dimaslanjaka/hexo/raw/monorepo-v7/releases/warehouse.tgz"
+};
+var packageManager = "yarn@4.5.1";
+var require$$4 = {
+	name: name,
+	version: version,
+	description: description,
+	main: main,
+	types: types,
+	type: type,
+	module: module,
+	exports: exports,
+	files: files,
+	scripts: scripts,
+	keywords: keywords,
+	repository: repository,
+	homepage: homepage,
+	author: author,
+	license: license,
+	workspaces: workspaces,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	resolutions: resolutions,
+	packageManager: packageManager
+};
+
+var is = {};
+
+/* eslint-disable @typescript-eslint/no-this-alias */
+
+var hasRequiredIs;
+
+function requireIs () {
+	if (hasRequiredIs) return is;
+	hasRequiredIs = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.tag = exports.category = exports.month = exports.year = exports.archive = exports.page = exports.post = exports.home = exports.current = void 0;
+		exports.default = internalIs;
+		function isCurrentHelper(path, strict) {
+		    if (path === void 0) { path = "/"; }
+		    var currentPath = this.path.replace(/^[^/].*/, "/$&");
+		    if (strict) {
+		        if (path.endsWith("/"))
+		            path += "index.html";
+		        path = path.replace(/^[^/].*/, "/$&");
+		        return currentPath === path;
+		    }
+		    path = path.replace(/\/index\.html$/, "/");
+		    if (path === "/")
+		        return currentPath === "/index.html";
+		    path = path.replace(/^[^/].*/, "/$&");
+		    return currentPath.startsWith(path);
+		}
+		function isHomeHelper() {
+		    return Boolean(this.page.__index);
+		}
+		function isPostHelper() {
+		    if (this.page) {
+		        var src = this.page["full_source"] || "";
+		        var layout = this.page.layout || "";
+		        if (layout.startsWith("post"))
+		            return true;
+		        if (layout.startsWith("page"))
+		            return false;
+		        if (src !== "") {
+		            return Boolean(this.page.__post) && src.includes("_posts");
+		        }
+		    }
+		    return Boolean(this.page.__post);
+		}
+		function isPageHelper() {
+		    if (this.page) {
+		        var src = this.page["full_source"] || "";
+		        var layout = this.page.layout || "";
+		        if (layout.startsWith("post"))
+		            return false;
+		        if (layout.startsWith("page"))
+		            return true;
+		        if (src !== "") {
+		            return Boolean(this.page.__post) && !src.includes("_posts");
+		        }
+		    }
+		    return Boolean(this.page.__page);
+		}
+		function isArchiveHelper() {
+		    return Boolean(this.page.archive);
+		}
+		function isYearHelper(year) {
+		    var page = this.page;
+		    if (!page.archive)
+		        return false;
+		    if (year) {
+		        return page.year === year;
+		    }
+		    return Boolean(page.year);
+		}
+		function isMonthHelper(year, month) {
+		    var page = this.page;
+		    if (!page.archive)
+		        return false;
+		    if (year) {
+		        if (month) {
+		            return page.year === year && page.month === month;
+		        }
+		        return page.month === year;
+		    }
+		    return Boolean(page.year && page.month);
+		}
+		function isCategoryHelper(category) {
+		    if (category) {
+		        return this.page.category === category;
+		    }
+		    return Boolean(this.page.category);
+		}
+		function isTagHelper(tag) {
+		    if (tag) {
+		        return this.page.tag === tag;
+		    }
+		    return Boolean(this.page.tag);
+		}
+		exports.current = isCurrentHelper;
+		exports.home = isHomeHelper;
+		exports.post = isPostHelper;
+		exports.page = isPageHelper;
+		exports.archive = isArchiveHelper;
+		exports.year = isYearHelper;
+		exports.month = isMonthHelper;
+		exports.category = isCategoryHelper;
+		exports.tag = isTagHelper;
+		/**
+		 * Custom function
+		 * @param hexo
+		 * @returns
+		 */
+		function internalIs(hexo) {
+		    var obj = {
+		        current: false,
+		        home: false,
+		        post: false,
+		        page: false,
+		        archive: false,
+		        year: false,
+		        month: false,
+		        category: false,
+		        tag: false,
+		        message: "try using second argument",
+		    };
+		    if (typeof hexo["page"] == "undefined")
+		        return obj;
+		    return {
+		        current: exports.current.bind(hexo)(),
+		        home: exports.home.bind(hexo)(),
+		        post: exports.post.bind(hexo)(),
+		        page: exports.page.bind(hexo)(),
+		        archive: exports.archive.bind(hexo)(),
+		        year: exports.year.bind(hexo)(),
+		        month: exports.month.bind(hexo)(),
+		        category: exports.category.bind(hexo)(),
+		        tag: exports.tag.bind(hexo)(),
+		    };
+		} 
+	} (is));
+	return is;
+}
+
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	(function (exports) {
+		var __createBinding = (src && src.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __setModuleDefault = (src && src.__setModuleDefault) || (Object.create ? (function(o, v) {
+		    Object.defineProperty(o, "default", { enumerable: true, value: v });
+		}) : function(o, v) {
+		    o["default"] = v;
+		});
+		var __importStar = (src && src.__importStar) || function (mod) {
+		    if (mod && mod.__esModule) return mod;
+		    var result = {};
+		    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		    __setModuleDefault(result, mod);
+		    return result;
+		};
+		var __importDefault = (src && src.__importDefault) || function (mod) {
+		    return (mod && mod.__esModule) ? mod : { "default": mod };
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.hexoIs = void 0;
+		exports.hexoIsDump = hexoIsDump;
+		/* eslint-disable prefer-rest-params */
+		var fs$1 = __importStar(fs);
+		var hexo_log_1 = __importDefault(require$$1);
+		var path_1 = __importDefault(path);
+		var util_1 = __importDefault(require$$3);
+		var package_json_1 = __importDefault(require$$4);
+		var is_1 = __importDefault(requireIs());
+		var log = (0, hexo_log_1.default)({
+		    debug: false,
+		    silent: false,
+		});
+		/**
+		 * @example
+		 * // run inside plugin or theme event
+		 * import hexoIs from 'hexo-is';
+		 * const hexo = this;
+		 * console.log(hexoIs(hexo)); // object or string
+		 * @param hexo
+		 * @returns
+		 */
+		var hexoIs = function (hexo) {
+		    if (typeof hexo === "undefined")
+		        return;
+		    if (typeof hexo["page"] != "undefined")
+		        return (0, is_1.default)(hexo);
+		    if (typeof hexo["type"] != "undefined") {
+		        var ix = (0, is_1.default)(hexo);
+		        if (typeof ix[hexo["type"]] != "undefined")
+		            ix[hexo["type"]] = true;
+		        return ix;
+		    }
+		};
+		exports.hexoIs = hexoIs;
+		/**
+		 * Dump variable to file
+		 * @param toDump
+		 */
+		function hexoIsDump(toDump, name) {
+		    if (name === void 0) { name = ""; }
+		    if (name.length > 0)
+		        name = "-" + name;
+		    var dump = util_1.default.inspect(toDump, { showHidden: true, depth: null });
+		    var loc = path_1.default.join("tmp/hexo-is/dump" + name + ".txt");
+		    if (!fs$1.existsSync(path_1.default.dirname(loc))) {
+		        fs$1.mkdirSync(path_1.default.dirname(loc), { recursive: true });
+		    }
+		    fs$1.writeFileSync(loc, dump);
+		    log.log("".concat(package_json_1.default.name, ": dump saved to: ").concat(path_1.default.resolve(loc)));
+		}
+		exports.default = exports.hexoIs; 
+	} (src));
+	return src;
+}
+
+var srcExports = requireSrc();
+var index = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+
+const argv = minimist(process.argv.slice(2));
+/**
+ * Check if the environment is production or development
+ * @param inHexo Hexo instance
+ * @returns Environment
+ */
+const getEnv = memoize((inHexo) => {
+    const DEV = 'development';
+    const PRD = 'production';
+    // Check if --development flag is set
+    const arg = typeof argv['development'] === 'boolean' && argv['development'];
+    // Check if NODE_ENV is set to "development"
+    const env = process.env.NODE_ENV?.toLowerCase() === 'development';
+    // Determine if environment is development
+    const isDev = arg || env;
+    if (inHexo) {
+        if (isDev)
+            return DEV;
+        if (typeof inHexo.env.args.development === 'boolean' && inHexo.env.args.development)
+            return DEV;
+        if (inHexo.env.args._ && inHexo.env.args._.length > 0) {
+            for (const arg of inHexo.env.args._) {
+                if (arg === 's' || arg === 'server')
+                    return DEV;
+                if (arg === 'd' || arg === 'deploy')
+                    return PRD;
+                if (arg === 'g' || arg === 'generate')
+                    return PRD;
+            }
+        }
+    }
+    return null;
+});
+/**
+ * Determine if the environment is development
+ * @param hexo Hexo instance
+ * @returns boolean
+ */
+const isDev = memoize((hexo) => getEnv(hexo) === 'development');
+/**
+ * Determine if the environment is production
+ * @param hexo Hexo instance
+ * @returns boolean
+ */
+memoize((hexo) => getEnv(hexo) === 'production');
+const defaultConfig = {
+    enable: true,
+    article_ads: [''].filter((v) => typeof v === 'string' && v.length > 0),
+    pub: '',
+    adblock: false,
+    https: false,
+    field: 'site',
+    type: 'javascript',
+    exclude: ['.gitignore'],
+    development: false
+};
+/**
+ * hexo-adsense config
+ * @param hexo
+ * @returns
+ */
+function getHexoAdsenseConfig(hexo) {
+    if (typeof hexo.config.adsense !== 'undefined') {
+        if (typeof hexo.config.adsense === 'boolean') {
+            // fix when adsense: false
+            hexo.config.adsense = {};
+            hexo.config.adsense.enable = hexo.config.adsense;
+        }
+        const config = assign(defaultConfig, hexo.config.adsense);
+        config.development = defaultConfig.development = isDev(hexo);
+        return config;
+    }
+    return defaultConfig;
+}
+
+const logname = ansiColors.magentaBright('hexo-adsense');
+const once = (function (...fn) {
+    let executed = false;
+    return function () {
+        if (!executed) {
+            executed = true;
+            // Do something
+            if (typeof fn[0] === 'function')
+                return fn[0]();
+            console.log(fn);
+        }
+    };
+})();
+function stack(msg) {
+    const logLineDetails = new Error().stack?.split('at ')[3].trim();
+    console.log('DEBUG', new Date().toUTCString(), logLineDetails, msg);
+}
+const defaultLogger = typeof hexo !== 'undefined' ? hexo.log : require$$1({ silent: false, debug: true });
+const logger = {
+    stack,
+    once
+};
+const debugLog = function (...args) {
+    debug('hexo-adsense')(...args);
+    defaultLogger.debug(logname, ...args);
+};
+var logger$1 = Object.assign(defaultLogger, logger);
+
+// ESM-compatible __dirname replacement
+path.dirname(fileURLToPath(import.meta.url));
+/**
+ * @param path0
+ * @param exclude
+ * @param hexo
+ * @returns boolean
+ */
+const isIgnore = (path0, exclude, hexo) => {
+    if (exclude && !Array.isArray(exclude))
+        exclude = [exclude];
+    if (path0 && exclude && exclude.length) {
+        for (let i = 0, len = exclude.length; i < len; i++) {
+            const excludePattern = exclude[i];
+            if (hexo) {
+                const fromBase = normalizePathUnix(hexo.base_dir, excludePattern);
+                const fromSource = normalizePathUnix(hexo.source_dir, excludePattern);
+                if (minimatch(path0, fromSource))
+                    return true;
+                if (minimatch(path0, fromBase))
+                    return true;
+            }
+            if (minimatch(path0, excludePattern))
+                return true;
+        }
+    }
+    return false;
+};
+const tmpFolder = normalizePath(typeof hexo !== 'undefined' ? hexo.base_dir : process.cwd(), 'tmp/hexo-adsense');
+
+// ESM-compatible __dirname replacement
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+const adsContent = `<div hexo-adsense="ads-content">ADS_CODE_HERE</div>`;
+String.prototype.joinpath = function (str) {
+    return path.join(this.toString(), str);
+};
+function parseConfig(hexo) {
+    return getHexoAdsenseConfig(hexo);
+}
+function articleAds(files, hexo) {
+    const base_dir = hexo.base_dir;
+    const source_dir = hexo.source_dir;
+    const isDevelopment = parseConfig(hexo).development;
+    const result = [];
+    files.forEach((file) => {
+        let html = '';
+        let tes = base_dir.joinpath(file);
+        if (fs$1.existsSync(tes)) {
+            html = fs$1.readFileSync(tes).toString();
+        }
+        else {
+            tes = source_dir.joinpath(file);
+            if (fs$1.existsSync(tes)) {
+                html = fs$1.readFileSync(tes).toString();
+            }
+        }
+        if (html.length > 0) {
+            if (isDevelopment) {
+                html = html.replace(/><\/ins>/gm, ` data-adtest="on"></ins>`);
+            }
+            html = html.replace(/\(adsbygoogle?\s*=?\s*window\.adsbygoogle?\s*\|\|?\s*\[\]\)\.push\({}\);/gm, '');
+            html = html.replace(/<script?.*src?.*adsbygoogle\b[^>]*>([\s\S]*?)<\/script>/gm, '');
+            result.push(adsContent.replace('ADS_CODE_HERE', html));
+        }
+    });
+    return result;
+}
+function filter_adshtml(hexo) {
+    const options = parseConfig(hexo);
+    let adshtml = [];
+    if (Array.isArray(options.article_ads)) {
+        // array of file paths
+        adshtml = options.article_ads;
+    }
+    else if (typeof options.article_ads === 'string') {
+        // single file path
+        adshtml = [options.article_ads];
+    }
+    else if (typeof options.article_ads === 'boolean') {
+        // scan source_dir/_data/hexo-adsense/*.html
+        adshtml = globSync([`${hexo.config.source_dir}/ads/**/*.html`, `${hexo.config.source_dir}/_data/hexo-adsense/**/*.html`], {
+            cwd: hexo.base_dir
+        });
+    }
+    if (adshtml.length > 0) {
+        adshtml = adshtml.filter((ads) => typeof ads === 'string' && ads.trim().length > 0);
+        if (adshtml.length > 0) {
+            adshtml = articleAds(adshtml, hexo);
+        }
+    }
+    return adshtml;
+}
+function filter_patterns(content, source_path, hexo) {
+    const options = parseConfig(hexo);
+    const excluded = isIgnore(source_path, options.exclude, hexo);
+    if (excluded) {
+        content = content.replace(/<script?.*src?.*adsbygoogle?\b[^>]*>([\s\S]*?)<\/script>/gm, '<!--hexo-adsense disabled on this page-->');
+    }
+    return {
+        content,
+        excluded
+    };
+}
+function after_post_render(data) {
+    const hexo = this;
+    const options = parseConfig(hexo);
+    const filterPattern = filter_patterns(data.content, getPageSource(data), hexo);
+    data.content = filterPattern.content;
+    if (filterPattern.excluded)
+        return data;
+    const adshtml = filter_adshtml(hexo);
+    if (adshtml.length < 1)
+        return data;
+    if (typeof data.adsense === 'boolean' && data.adsense) {
+        data.content = processAdsHtml(data.content, adshtml, hexo);
+    }
+    else if (options.enable) {
+        data.content = processAdsHtml(data.content, adshtml, hexo);
+    }
+    return data;
+}
+function processAdsHtml(content, adshtml, hexo) {
+    const options = parseConfig(hexo);
+    const replacement = memoize((adshtml) => {
+        const adsContentCss = path.join(__dirname$1, 'source/article-ads.css');
+        const adsContentJs = path.join(__dirname$1, 'source/article-ads.js');
+        let replacement = `<div id="hexo-adsense-hidden" style="display:none">${adshtml.join('')}</div>`;
+        if (fs$1.existsSync(adsContentCss))
+            replacement += `<style>${fs$1.readFileSync(adsContentCss).toString()}</style>`;
+        if (fs$1.existsSync(adsContentJs))
+            replacement += `<script>${fs$1.readFileSync(adsContentJs).toString()}</script>`;
+        return replacement;
+    });
+    const caller = new Error().stack?.split('at ')[2].replace(/^Hexo./g, '');
+    const isFieldPost = caller?.startsWith('after_post_render');
+    if (isFieldPost) {
+        content += replacement(adshtml);
+    }
+    else {
+        if (!options.enable) {
+            content = content.replace(/<\/head>/gm, `<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=${options.pub}" crossorigin="anonymous"></script>`);
+        }
+        content = content.replace(/<\/body>/gm, `${replacement(adshtml)}</body>`);
+    }
+    return content;
+}
+function getPageSource(page) {
+    return page.full_source || page.source || page.path || page.canonical_path;
+}
+function after_render_html(content, data) {
+    const hexo = this;
+    const options = parseConfig(hexo);
+    const where = index(data);
+    const page = data.post ?? data.page;
+    const isPageAdsenseEnabled = typeof page.adsense === 'boolean' ? page.adsense : options.enable;
+    if (options.field === 'post') {
+        if (where.category || where.archive || where.home || where.tag) {
+            debugLog(`config field for post, skipping ${data.path || '<empty path>'}`);
+            return content;
+        }
+    }
+    debugLog(page.path, 'is adsense enabled', isPageAdsenseEnabled);
+    if (isPageAdsenseEnabled) {
+        const filterPattern = filter_patterns(content, getPageSource(page), hexo);
+        if (filterPattern.excluded)
+            return filterPattern.content;
+        const adshtml = filter_adshtml(hexo);
+        if (adshtml.length < 1)
+            return content;
+        if (page.adsense || options.enable) {
+            content = processAdsHtml(content, adshtml, hexo);
+        }
+        const pageAd = `<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=${options.pub}" crossorigin="anonymous"></script>`;
+        content = content.replace(/<\/head>/, pageAd + '</head>');
+    }
+    return content;
+}
+
+/* global hexo */
+// ESM-compatible __dirname replacement
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+if (typeof hexo !== 'undefined' && typeof hexo.config.adsense !== 'undefined') {
+    // const injector = injector2(hexo); // Create injector plugin
+    const config = getHexoAdsenseConfig(hexo);
+    const isDevelopment = config.development;
+    // clean temp folder on `hexo clean`
+    hexo.extend.filter.register('after_clean', function () {
+        // remove some other temporary files
+        hexo.log.debug(logname + '(clean)', 'cleaning temp folder');
+        if (fs$2.existsSync(tmpFolder))
+            fs$2.rmSync(tmpFolder, { recursive: true, force: true });
+    });
+    if (config.pub.length < 1) {
+        logger$1.error(logname + '(config)', `adsense ca-pub (adsense.pub) not configured in _config.yml`);
+    }
+    else {
+        if (config.enable) {
+            // Write config on </head>
+            // injector.register('head_end', function () {
+            //   const adsenseConfigObject = JSON.stringify(
+            //     assign(config, hexo.env, { adsense: hexo.config.adsense }),
+            //     null,
+            //     isDevelopment ? 2 : undefined
+            //   );
+            //   return `<script id="hexo-adsense-config" type="application/json">${adsenseConfigObject}</script>`;
+            // });
+            hexo.extend.filter.register('after_render:html', function (content, _data) {
+                const lastBodyRegex = /<\/body>(?=[^<]*$)/;
+                const firstHeadRegex = /<\/head>/;
+                const adsenseConfigObject = JSON.stringify(assign(config, hexo.env, { adsense: hexo.config.adsense }), null, isDevelopment ? 2 : undefined);
+                const script = `<script id="hexo-adsense-config" type="application/json">${adsenseConfigObject}</script>`;
+                // Apply functions only in production
+                if (!isDevelopment) {
+                    // Redirect to HTTPS if configured
+                    if (typeof config.https === 'boolean' && config.https) {
+                        const https_js = fs$2.readFileSync(path.join(__dirname, 'source/https.js'), 'utf-8');
+                        content = content.replace(lastBodyRegex, `<script>${https_js}</script></body>`);
+                    }
+                    // Add adblock blocker if configured
+                    if (typeof config.adblock === 'boolean' && config.adblock) {
+                        const adblock_css = fs$2.readFileSync(path.join(__dirname, 'source/adblock.css'), 'utf-8');
+                        const adblock_js = fs$2.readFileSync(path.join(__dirname, 'source/adblock.js'), 'utf-8');
+                        content = content.replace(lastBodyRegex, `<style>${adblock_css}</style><script>${adblock_js}</script></body>`);
+                    }
+                }
+                return content.replace(firstHeadRegex, script + '</head>');
+            });
+            // Handle article ads if configured
+            if (typeof config.article_ads !== 'undefined') {
+                if (config.field === 'post') {
+                    logger$1.info(logname, 'apply adsense only for posts');
+                    // Apply to posts
+                    hexo.extend.filter.register('after_post_render', after_post_render);
+                }
+                else {
+                    logger$1.info(logname, 'apply adsense for all sites pages and posts');
+                    // Apply to entire HTML
+                    hexo.extend.filter.register('after_render:html', after_render_html);
+                }
+            }
+            // Prettify on development
+            if (hexo.env.cmd === 'server' && isDevelopment) {
+                hexo.extend.filter.register('after_render:html', async function (content, _page) {
+                    const format = await prettier.format(content, { parser: 'html' });
+                    debugLog(`Prettier formatted html result of ${_page.path}`);
+                    return format;
+                });
+            }
+        }
+    }
+}