mirror of
https://github.com/SukkaW/Surge.git
synced 2025-12-21 05:40:29 +08:00
305 lines
14 KiB
JavaScript
305 lines
14 KiB
JavaScript
'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; |