'use strict';Object.defineProperty(exports,Symbol.toStringTag,{value:'Module'});const buildDomesticDirectLanRulesetDnsMappingModule=require('../_virtual/build-domestic-direct-lan-ruleset-dns-mapping-module.cjs'),require$$0=require('node:path'),domestic=require('../Source/non_ip/domestic.cjs'),direct=require('../Source/non_ip/direct.cjs'),fetchTextByLine=require('./lib/fetch-text-by-line.cjs'),createFile=require('./lib/create-file.cjs'),index=require('./trace/index.cjs'),description=require('./constants/description.cjs'),memoPromise=require('./lib/memo-promise.cjs'),require$$8=require('yaml'),appendArrayInPlace=require('./lib/append-array-in-place.cjs'),dir=require('./constants/dir.cjs'),ruleset=require('./lib/rules/ruleset.cjs');var hasRequiredBuildDomesticDirectLanRulesetDnsMappingModule;

function requireBuildDomesticDirectLanRulesetDnsMappingModule () {
	if (hasRequiredBuildDomesticDirectLanRulesetDnsMappingModule) return buildDomesticDirectLanRulesetDnsMappingModule.__module.exports;
	hasRequiredBuildDomesticDirectLanRulesetDnsMappingModule = 1;
	(function (module, exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		function _export(target, all) {
		    for(var name in all)Object.defineProperty(target, name, {
		        enumerable: true,
		        get: all[name]
		    });
		}
		_export(exports, {
		    buildDomesticRuleset: function() {
		        return buildDomesticRuleset;
		    },
		    createGetDnsMappingRule: function() {
		        return createGetDnsMappingRule;
		    },
		    getDomesticAndDirectDomainsRulesetPromise: function() {
		        return getDomesticAndDirectDomainsRulesetPromise;
		    }
		});
		const _nodepath = /*#__PURE__*/ _interop_require_default(require$$0);
		const _domestic = /*@__PURE__*/ domestic.__require();
		const _direct = /*@__PURE__*/ direct.__require();
		const _fetchtextbyline = /*@__PURE__*/ fetchTextByLine.__require();
		const _createfile = /*@__PURE__*/ createFile.__require();
		const _trace = /*@__PURE__*/ index.__require();
		const _description = /*@__PURE__*/ description.__require();
		const _memopromise = /*@__PURE__*/ memoPromise.__require();
		const _yaml = /*#__PURE__*/ _interop_require_wildcard(require$$8);
		const _appendarrayinplace = /*@__PURE__*/ appendArrayInPlace.__require();
		const _dir = /*@__PURE__*/ dir.__require();
		const _ruleset = /*@__PURE__*/ ruleset.__require();
		function _interop_require_default(obj) {
		    return obj && obj.__esModule ? obj : {
		        default: obj
		    };
		}
		function _getRequireWildcardCache(nodeInterop) {
		    if (typeof WeakMap !== "function") return null;
		    var cacheBabelInterop = new WeakMap();
		    var cacheNodeInterop = new WeakMap();
		    return (_getRequireWildcardCache = function(nodeInterop) {
		        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
		    })(nodeInterop);
		}
		function _interop_require_wildcard(obj, nodeInterop) {
		    if (obj && obj.__esModule) {
		        return obj;
		    }
		    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
		        return {
		            default: obj
		        };
		    }
		    var cache = _getRequireWildcardCache(nodeInterop);
		    if (cache && cache.has(obj)) {
		        return cache.get(obj);
		    }
		    var newObj = {
		        __proto__: null
		    };
		    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
		    for(var key in obj){
		        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
		            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
		            if (desc && (desc.get || desc.set)) {
		                Object.defineProperty(newObj, key, desc);
		            } else {
		                newObj[key] = obj[key];
		            }
		        }
		    }
		    newObj.default = obj;
		    if (cache) {
		        cache.set(obj, newObj);
		    }
		    return newObj;
		}
		function createGetDnsMappingRule(allowWildcard) {
		    const hasWildcard = (domain)=>{
		        if (domain.includes('*') || domain.includes('?')) {
		            if (!allowWildcard) {
		                throw new TypeError(`Wildcard domain is not supported: ${domain}`);
		            }
		            return true;
		        }
		        return false;
		    };
		    return (domain)=>{
		        const results = [];
		        if (domain[0] === '$') {
		            const d = domain.slice(1);
		            if (hasWildcard(domain)) {
		                results.push(`DOMAIN-WILDCARD,${d}`);
		            } else {
		                results.push(`DOMAIN,${d}`);
		            }
		        } else if (domain[0] === '+') {
		            const d = domain.slice(1);
		            if (hasWildcard(domain)) {
		                results.push(`DOMAIN-WILDCARD,*.${d}`);
		            } else {
		                results.push(`DOMAIN-SUFFIX,${d}`);
		            }
		        } else if (hasWildcard(domain)) {
		            results.push(`DOMAIN-WILDCARD,${domain}`, `DOMAIN-WILDCARD,*.${domain}`);
		        } else {
		            results.push(`DOMAIN-SUFFIX,${domain}`);
		        }
		        return results;
		    };
		}
		const getDomesticAndDirectDomainsRulesetPromise = (0, _memopromise.createMemoizedPromise)(async ()=>{
		    const domestics = await (0, _fetchtextbyline.readFileIntoProcessedArray)(_nodepath.default.join(_dir.SOURCE_DIR, 'non_ip/domestic.conf'));
		    const directs = await (0, _fetchtextbyline.readFileIntoProcessedArray)(_nodepath.default.resolve(_dir.SOURCE_DIR, 'non_ip/direct.conf'));
		    const lans = [];
		    const getDnsMappingRuleWithWildcard = createGetDnsMappingRule(true);
		    [
		        _domestic.DOH_BOOTSTRAP,
		        _domestic.DOMESTICS
		    ].forEach((item)=>{
		        Object.values(item).forEach(({ domains })=>{
		            (0, _appendarrayinplace.appendArrayInPlace)(domestics, domains.flatMap(getDnsMappingRuleWithWildcard));
		        });
		    });
		    Object.values(_direct.DIRECTS).forEach(({ domains })=>{
		        (0, _appendarrayinplace.appendArrayInPlace)(directs, domains.flatMap(getDnsMappingRuleWithWildcard));
		    });
		    Object.values(_direct.LAN).forEach(({ domains })=>{
		        (0, _appendarrayinplace.appendArrayInPlace)(directs, domains.flatMap(getDnsMappingRuleWithWildcard));
		    });
		    return [
		        domestics,
		        directs,
		        lans
		    ];
		});
		const buildDomesticRuleset = (0, _trace.task)(require.main === module, __filename)(async (span)=>{
		    const [domestics, directs, lans] = await getDomesticAndDirectDomainsRulesetPromise();
		    const dataset = [
		        _domestic.DOH_BOOTSTRAP,
		        _domestic.DOMESTICS,
		        _direct.DIRECTS,
		        _direct.LAN
		    ].flatMap(Object.entries);
		    return Promise.all([
		        new _ruleset.RulesetOutput(span, 'domestic', 'non_ip').withTitle('Sukka\'s Ruleset - Domestic Domains').withDescription([
		            ..._description.SHARED_DESCRIPTION,
		            '',
		            'This file contains known addresses that are avaliable in the Mainland China.'
		        ]).addFromRuleset(domestics).write(),
		        new _ruleset.RulesetOutput(span, 'direct', 'non_ip').withTitle('Sukka\'s Ruleset - Direct Rules').withDescription([
		            ..._description.SHARED_DESCRIPTION,
		            '',
		            'This file contains domains and process that should not be proxied.'
		        ]).addFromRuleset(directs).write(),
		        new _ruleset.RulesetOutput(span, 'lan', 'non_ip').withTitle('Sukka\'s Ruleset - LAN').withDescription([
		            ..._description.SHARED_DESCRIPTION,
		            '',
		            'This file includes rules for LAN DOMAIN and reserved TLDs.'
		        ]).addFromRuleset(lans).write(),
		        ...dataset.map(([name, { ruleset, domains }])=>{
		            if (!ruleset) {
		                return;
		            }
		            const output = new _ruleset.SurgeOnlyRulesetOutput(span, name.toLowerCase(), 'sukka_local_dns_mapping', _dir.OUTPUT_MODULES_RULES_DIR).withTitle(`Sukka's Ruleset - Local DNS Mapping (${name})`).withDescription([
		                ..._description.SHARED_DESCRIPTION,
		                '',
		                'This is an internal rule that is only referenced by sukka_local_dns_mapping.sgmodule',
		                'Do not use this file in your Rule section, all rules are included in non_ip/domestic.conf already.'
		            ]);
		            domains.forEach((domain)=>{
		                switch(domain[0]){
		                    case '$':
		                        output.addDomain(domain.slice(1));
		                        break;
		                    case '+':
		                        output.addDomainSuffix(domain.slice(1));
		                        break;
		                    default:
		                        output.addDomainSuffix(domain);
		                        break;
		                }
		            });
		            return output.write();
		        }),
		        (0, _createfile.compareAndWriteFile)(span, [
		            '#!name=[Sukka] Local DNS Mapping',
		            `#!desc=Last Updated: ${new Date().toISOString()}`,
		            '',
		            '[Host]',
		            ...Object.entries(// I use an object to deduplicate the domains
		            // Otherwise I could just construct an array directly
		            dataset.reduce((acc, cur)=>{
		                const ruleset_name = cur[0].toLowerCase();
		                const { domains, dns, hosts, ruleset } = cur[1];
		                Object.entries(hosts).forEach(([dns, ips])=>{
		                    acc[dns] ||= ips.join(', ');
		                });
		                if (ruleset) {
		                    acc[`RULE-SET:https://ruleset.skk.moe/Modules/Rules/sukka_local_dns_mapping/${ruleset_name}.conf`] ||= `server:${dns}`;
		                } else {
		                    domains.forEach((domain)=>{
		                        switch(domain[0]){
		                            case '$':
		                                acc[domain.slice(1)] ||= `server:${dns}`;
		                                break;
		                            case '+':
		                                acc[`*.${domain.slice(1)}`] ||= `server:${dns}`;
		                                break;
		                            default:
		                                acc[domain] ||= `server:${dns}`;
		                                acc[`*.${domain}`] ||= `server:${dns}`;
		                                break;
		                        }
		                    });
		                }
		                return acc;
		            }, {})).map(([dns, ips])=>`${dns} = ${ips}`)
		        ], _nodepath.default.resolve(_dir.OUTPUT_MODULES_DIR, 'sukka_local_dns_mapping.sgmodule')),
		        (0, _createfile.compareAndWriteFile)(span, _yaml.stringify(dataset.reduce((acc, cur)=>{
		            const { domains, dns, ...rest } = cur[1];
		            domains.forEach((domain)=>{
		                switch(domain[0]){
		                    case '$':
		                        domain = domain.slice(1);
		                        break;
		                    case '+':
		                        domain = `*.${domain.slice(1)}`;
		                        break;
		                    default:
		                        domain = `+.${domain}`;
		                        break;
		                }
		                acc.dns['nameserver-policy'][domain] = dns === 'system' ? [
		                    'system://',
		                    'system',
		                    'dhcp://system'
		                ] : dns;
		            });
		            if ('hosts' in rest) {
		                Object.assign(acc.hosts, rest.hosts);
		            }
		            return acc;
		        }, {
		            dns: {
		                'nameserver-policy': {}
		            },
		            hosts: {}
		        }), {
		            version: '1.1'
		        }).split('\n'), _nodepath.default.join(_dir.OUTPUT_INTERNAL_DIR, 'clash_nameserver_policy.yaml')),
		        (0, _createfile.compareAndWriteFile)(span, [
		            '# Local DNS Mapping for AdGuard Home',
		            'tls://1.12.12.12',
		            'tls://120.53.53.53',
		            'https://1.12.12.12/dns-query',
		            'https://120.53.53.53/dns-query',
		            '[//]udp://10.10.1.1:53',
		            ...[
		                _domestic.DOMESTICS,
		                _direct.DIRECTS,
		                _direct.LAN
		            ].flatMap(Object.values).flatMap(({ domains, dns: _dns })=>domains.flatMap((domain)=>{
		                    let dns;
		                    if (_dns in _domestic.AdGuardHomeDNSMapping) {
		                        dns = _domestic.AdGuardHomeDNSMapping[_dns].join(' ');
		                    } else {
		                        console.warn(`Unknown DNS "${_dns}" not in AdGuardHomeDNSMapping`);
		                        dns = _dns;
		                    }
		                    // if (
		                    //   // AdGuard Home has built-in AS112 / private PTR handling
		                    //   domain.endsWith('.arpa')
		                    //   // Ignore simple hostname
		                    //   || !domain.includes('.')
		                    // ) {
		                    //   return [];
		                    // }
		                    if (domain[0] === '$') {
		                        return [
		                            `[/${domain.slice(1)}/]${dns}`
		                        ];
		                    }
		                    if (domain[0] === '+') {
		                        return [
		                            `[/${domain.slice(1)}/]${dns}`
		                        ];
		                    }
		                    return [
		                        `[/${domain}/]${dns}`
		                    ];
		                }))
		        ], _nodepath.default.resolve(_dir.OUTPUT_INTERNAL_DIR, 'dns_mapping_adguardhome.conf'))
		    ]);
		}); 
	} (buildDomesticDirectLanRulesetDnsMappingModule.__module, buildDomesticDirectLanRulesetDnsMappingModule.__module.exports));
	return buildDomesticDirectLanRulesetDnsMappingModule.__module.exports;
}exports.__require=requireBuildDomesticDirectLanRulesetDnsMappingModule;