rewrite: [
 {
 // Redirect all https://slack.com/app_redirect?team=team=apegroup&channel=random 
 // to slack://channel?team=apegroup&id=random
 match: ({ url }) => url.host.includes("slack.com") && url.pathname.includes("app_redirect"),
 url({ url }) {
 const team = url.search.split('&').filter(part => part.startsWith('team'));
 var channel = "" + url.search.split('&').filter(part => part.startsWith('channel'));
 var id = channel.replace("channel", "id");
 return {
 protocol: "slack",
 username: "",
 password: "",
 host: "channel",
 port: null,
 pathname: "",
 search : team + '&' + id,
 hash: ""
 }
 
 }
 } 
 ]

 handlers: [
 {
 // Redirect all web links
 // from: https://app.slack.com/client/<team id>/<channel>
 // to: slack://channel?team=<team-id>&id=<channel-id>
 //
 // Redirect all deep linked messages
 // from: https://<subdomain>.slack.com/archives/<channel-id>/p<16-digit-timestamp>
 // to: slack://channel?team=<team-id>&id=<channel-id>&message=<10-digit-6-decimal-timestamp> 
 browser: "/Applications/Slack.app",
 match: [
 '*.slack.com/client/*',
 '*.slack.com/archives/*'
 ],
 url({ url }) {
 const parts = url.pathname.split('/')
 // Return input URL if no expected path is found
 if (parts.length < 2) return url
 let team
 switch (parts[1]) {
 // For direct web links
 case 'client':
 team = parts[2]
 parts.splice(2, 1) // Remove team identifier to match archives format
 break
 // For deep links
 case 'archives':
 const org = url.host.split('.')[0]
 switch (org) {
 case '<org subdomain>':
 // Starts with a T and can be found in the web app URL for any channel in your org
 team = '<team id>'
 break
 default:
 // Return input URL if no team lookup available
 return url
 }
 }
 search = `team=${team}`
 let channel = parts[2]
 if (parts.length === 3) {
 // If this is a link to a channel/user
 search = `${search}&id=${channel}`
 // If this is a link to a message
 } else if (parts.length === 4) {
 const message = parts[3].slice(1, 11) + '.' + parts[3].slice(11)
 search = `${search}&channel=${channel}&message=${message}`
 }
 return {
 protocol: "slack",
 username: "",
 password: "",
 host: "channel",
 port: null,
 pathname: "",
 search: search,
 hash: ""
 }
 }
 }
 ]

module.exports = {
 handlers: [
 {
 match: ({ url }) => url.protocol === "slack",
 browser: "/Applications/Slack.app"
 }
 ],
 rewrite: [
 {
 match: [
 '*.slack.com/*',
 ],
 url: function({ url, urlString }) {
 const subdomain = url.host.slice(0, -10)
 const pathParts = url.pathname.split("/")
 let team, patterns = {}
 if (subdomain != 'app') {
 switch (subdomain) {
 case '<teamname>':
 case '<corpname>.enterprise':
 team = 'T00000000'
 break
 default:
 finicky.notify(
 `No Slack team ID found for ${url.host}`, 
 `Add the team ID to ~/.finicky.js to allow direct linking to Slack.`
 )
 return url
 }
 
 if (subdomain.slice(-11) == '.enterprise') {
 patterns = {
 'file': [/\/files\/\w+\/(?<id>\w+)/]
 }
 } else {
 patterns = {
 'file': [/\/messages\/\w+\/files\/(?<id>\w+)/],
 'team': [/(?:\/messages\/\w+)?\/team\/(?<id>\w+)/],
 'channel': [/\/(?:messages|archives)\/(?<id>\w+)(?:\/(?<message>p\d+))?/]
 }
 }
 } else {
 patterns = {
 'file': [
 /\/client\/(?<team>\w+)\/\w+\/files\/(?<id>\w+)/,
 /\/docs\/(?<team>\w+)\/(?<id>\w+)/
 ],
 'team': [/\/client\/(?<team>\w+)\/\w+\/user_profile\/(?<id>\w+)/],
 'channel': [/\/client\/(?<team>\w+)\/(?<id>\w+)(?:\/(?<message>[\d.]+))?/]
 }
 }
 
 for (let [host, host_patterns] of Object.entries(patterns)) {
 for (let pattern of host_patterns) {
 let match = pattern.exec(url.pathname)
 if (match) {
 let search = `team=${team || match.groups.team}`
 if (match.groups.id) {
 search += `&id=${match.groups.id}`
 }
 if (match.groups.message) {
 let message = match.groups.message
 if (message.charAt(0) == 'p') {
 message = message.slice(1, 11) + '.' + message.slice(11)
 }
 search += `&message=${message}`
 }
 let output = {
 protocol: "slack",
 username: "",
 password: "",
 host: host,
 port: null,
 pathname: "",
 search: search,
 hash: ""
 }
 let outputStr = `${output.protocol}://${output.host}?${output.search}`
 finicky.log(`Rewrote Slack URL ${urlString} to deep link ${outputStr}`)
 return output
 }
 }
 }
 return url
 }
 }
 ]
}

let output = {
 protocol: "slack",
 username: "",
 password: "",
 host: host,
 port: null,
 pathname: "",
 search: search,
 hash: ""
}
let outputStr = `${output.protocol}://${output.host}?${output.search}`
finicky.log(`Rewrote Slack URL ${urlString} to deep link ${outputStr}`)
return output

let outputStr = `slack://${host}?${search}`
console.log(`Rewrote Slack URL ${urlString} to deep link ${outputStr}`)
return outputStr

Note

Note that a number of optional URL parameters were removed, and will need to be added to outputStr

// Based on @opalelement's answer https://github.com/johnste/finicky/issues/96#issuecomment-844571182
// Team ID can be found in the browser URL : https://slack.com/help/articles/221769328-Locate-your-Slack-URL-or-ID
// Free, Pro, and Business+ plans => Team or workspace ID starts with a T in https://app.slack.com/client/TXXXXXXX/CXXXXXXX
// Enterprise grid plans => Org ID starts with an E in https://app.slack.com/client/EXXXXXXX/CXXXXXXX
const workSlackTeamMapping = {
 // 'subdomain': 'TXXXXXXX',
 // 'acmecorp.enterprise': 'EXXXXXXX',
 // 'acmecorp': 'EXXXXXXX',
};
const personalSlackMapping = {
 // personal slacks
};
const slackSubdomainMapping = {
 ...workSlackTeamMapping,
 ...personalSlackMapping,
};
const slackRewriter = {
 match: ["*.slack.com/*"],
 url: function (urlObj) {
 const subdomain = urlObj.host.slice(0, -10); // before .slack.com
 const pathParts = urlObj.pathname.split("/");
 let team,
 patterns = {};
 if (subdomain != "app") {
 if (!Object.keys(slackSubdomainMapping).includes(subdomain)) {
 console.log(
 `No Slack team ID found for ${urlObj.host}`,
 `Add a correct team ID to ~/.finicky.js to allow direct linking to Slack.`
 );
 return urlObj;
 }
 team = slackSubdomainMapping[subdomain];
 if (subdomain.slice(-11) == ".enterprise") {
 patterns = {
 file: [/\/files\/\w+\/(?<id>\w+)/],
 };
 } else {
 patterns = {
 file: [/\/messages\/\w+\/files\/(?<id>\w+)/],
 team: [/(?:\/messages\/\w+)?\/team\/(?<id>\w+)/],
 channel: [
 /\/(?:messages|archives)\/(?<id>\w+)(?:\/(?<message>p\d+))?/,
 ],
 };
 }
 } else {
 patterns = {
 file: [
 /\/client\/(?<team>\w+)\/\w+\/files\/(?<id>\w+)/,
 /\/docs\/(?<team>\w+)\/(?<id>\w+)/,
 ],
 team: [/\/client\/(?<team>\w+)\/\w+\/user_profile\/(?<id>\w+)/],
 channel: [
 /\/client\/(?<team>\w+)\/(?<id>\w+)(?:\/(?<message>[\d.]+))?/,
 ],
 };
 }
 for (let [host, host_patterns] of Object.entries(patterns)) {
 for (let pattern of host_patterns) {
 let match = pattern.exec(urlObj.pathname);
 if (match) {
 let search = `team=${team || match.groups.team}`;
 if (match.groups.id) {
 search += `&id=${match.groups.id}`;
 }
 if (match.groups.message) {
 let message = match.groups.message;
 if (message.charAt(0) == "p") {
 message = message.slice(1, 11) + "." + message.slice(11);
 }
 search += `&message=${message}`;
 }
 let outputStr = `slack://${host}?${search}`;
 console.log(
 `Rewrote Slack URL ${urlObj.href} to deep link ${outputStr}`
 );
 
 return new URL(outputStr);
 }
 }
 }
 return urlObj;
 },
};
module.exports = {
 defaultBrowser: "Arc",
 rewrite: [slackRewriter],
 handlers: [
 {
 match: ({ url }) => {
 // Check for both 'slack:' and 'slack' since the property might not include the colon
 return url.protocol === "slack:" || url.protocol === "slack";
 },
 browser: "Slack",
 },
 {
 // Optional. If these work url cannot be converted, open them is work browser
 // Login in work workspace unfortunately lands on the personal browser, just copy the link to the work browser
 match: ({ url }) => {
 const workDomains = Object.keys(workSlackTeamMapping).map(subdomain => subdomain + ".slack.com");
 return workDomains.includes(url.host);
 },
 browser: "Arc", // your work browser
 },
 ],
};