diff --git a/docs/cli/shortcuts.md b/docs/cli/shortcuts.md
index 36bbf19a..d0a79d8a 100644
--- a/docs/cli/shortcuts.md
+++ b/docs/cli/shortcuts.md
@@ -1,6 +1,6 @@
 # Command Shortcuts
 
-Package managers that execute scripts from a `package.json` file can be shortened when in concurrently.<br/>
+Package managers that execute scripts from a `package.json` or `deno.json` file can be shortened when in concurrently.<br/>
 The following are supported:
 
 | Syntax          | Expands to            |
@@ -10,6 +10,7 @@ The following are supported:
 | `yarn:<script>` | `yarn run <script>`   |
 | `bun:<script>`  | `bun run <script>`    |
 | `node:<script>` | `node --run <script>` |
+| `deno:<script>` | `deno task <script>`  |
 
 > [!NOTE]
 >
diff --git a/src/command-parser/expand-npm-shortcut.spec.ts b/src/command-parser/expand-npm-shortcut.spec.ts
deleted file mode 100644
index eb6ac202..00000000
--- a/src/command-parser/expand-npm-shortcut.spec.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { CommandInfo } from '../command';
-import { ExpandNpmShortcut } from './expand-npm-shortcut';
-
-const parser = new ExpandNpmShortcut();
-
-const createCommandInfo = (command: string, name = ''): CommandInfo => ({
-    name,
-    command,
-});
-
-it('returns same command if no npm: prefix is present', () => {
-    const commandInfo = createCommandInfo('echo foo');
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-describe.each([
-    ['npm', 'run'],
-    ['yarn', 'run'],
-    ['pnpm', 'run'],
-    ['bun', 'run'],
-    ['node', '--run'],
-])(`with %s: prefix`, (npmCmd, runCmd) => {
-    it(`expands to "${npmCmd} ${runCmd} <script> <args>"`, () => {
-        const commandInfo = createCommandInfo(`${npmCmd}:foo -- bar`, 'echo');
-        expect(parser.parse(commandInfo)).toEqual({
-            ...commandInfo,
-            name: 'echo',
-            command: `${npmCmd} ${runCmd} foo -- bar`,
-        });
-    });
-
-    it('sets name to script name if none', () => {
-        const commandInfo = createCommandInfo(`${npmCmd}:foo -- bar`);
-        expect(parser.parse(commandInfo)).toEqual({
-            ...commandInfo,
-            name: 'foo',
-            command: `${npmCmd} ${runCmd} foo -- bar`,
-        });
-    });
-});
diff --git a/src/command-parser/expand-npm-shortcut.ts b/src/command-parser/expand-npm-shortcut.ts
deleted file mode 100644
index bc681582..00000000
--- a/src/command-parser/expand-npm-shortcut.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { CommandInfo } from '../command';
-import { CommandParser } from './command-parser';
-
-/**
- * Expands commands prefixed with `node:`, `npm:`, `yarn:`, `pnpm:`, or `bun:` into the full version `npm run <command>` and so on.
- */
-export class ExpandNpmShortcut implements CommandParser {
-    parse(commandInfo: CommandInfo) {
-        const [, npmCmd, cmdName, args] =
-            commandInfo.command.match(/^(node|npm|yarn|pnpm|bun):(\S+)(.*)/) || [];
-        if (!cmdName) {
-            return commandInfo;
-        }
-
-        const runCmd = npmCmd === 'node' ? '--run' : 'run';
-        return {
-            ...commandInfo,
-            name: commandInfo.name || cmdName,
-            command: `${npmCmd} ${runCmd} ${cmdName}${args}`,
-        };
-    }
-}
diff --git a/src/command-parser/expand-npm-wildcard.spec.ts b/src/command-parser/expand-npm-wildcard.spec.ts
deleted file mode 100644
index f0a57285..00000000
--- a/src/command-parser/expand-npm-wildcard.spec.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import fs from 'fs';
-
-import { CommandInfo } from '../command';
-import { ExpandNpmWildcard } from './expand-npm-wildcard';
-
-let parser: ExpandNpmWildcard;
-let readPkg: jest.Mock;
-
-const createCommandInfo = (command: string): CommandInfo => ({
-    command,
-    name: '',
-});
-
-beforeEach(() => {
-    readPkg = jest.fn();
-    parser = new ExpandNpmWildcard(readPkg);
-});
-
-afterEach(() => {
-    jest.restoreAllMocks();
-});
-
-describe('ExpandNpmWildcard#readPackage', () => {
-    it('can read package', () => {
-        const expectedPackage = {
-            name: 'concurrently',
-            version: '6.4.0',
-        };
-        jest.spyOn(fs, 'readFileSync').mockImplementation((path) => {
-            if (path === 'package.json') {
-                return JSON.stringify(expectedPackage);
-            }
-            return '';
-        });
-
-        const actualReadPackage = ExpandNpmWildcard.readPackage();
-        expect(actualReadPackage).toEqual(expectedPackage);
-    });
-
-    it('can handle errors reading package', () => {
-        jest.spyOn(fs, 'readFileSync').mockImplementation(() => {
-            throw new Error('Error reading package');
-        });
-
-        expect(() => ExpandNpmWildcard.readPackage()).not.toThrow();
-        expect(ExpandNpmWildcard.readPackage()).toEqual({});
-    });
-});
-
-it('returns same command if not an npm run command', () => {
-    const commandInfo = createCommandInfo('npm test');
-
-    expect(readPkg).not.toHaveBeenCalled();
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-it('returns same command if no wildcard present', () => {
-    const commandInfo = createCommandInfo('npm run foo bar');
-
-    expect(readPkg).not.toHaveBeenCalled();
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-it('expands to nothing if no scripts exist in package.json', () => {
-    readPkg.mockReturnValue({});
-
-    expect(parser.parse(createCommandInfo('npm run foo-*-baz qux'))).toEqual([]);
-});
-
-describe.each([
-    ['npm', 'run'],
-    ['yarn', 'run'],
-    ['pnpm', 'run'],
-    ['bun', 'run'],
-    ['node', '--run'],
-])(`with a %s: prefix`, (npmCmd, runCmd) => {
-    it('expands to all scripts matching pattern', () => {
-        readPkg.mockReturnValue({
-            scripts: {
-                'foo-bar-baz': '',
-                'foo--baz': '',
-            },
-        });
-
-        expect(parser.parse(createCommandInfo(`${npmCmd} ${runCmd} foo-*-baz qux`))).toEqual([
-            { name: 'bar', command: `${npmCmd} ${runCmd} foo-bar-baz qux` },
-            { name: '', command: `${npmCmd} ${runCmd} foo--baz qux` },
-        ]);
-    });
-
-    it('uses wildcard match of script as command name', () => {
-        readPkg.mockReturnValue({
-            scripts: {
-                'watch-js': '',
-                'watch-css': '',
-            },
-        });
-
-        expect(
-            parser.parse({
-                name: '',
-                command: `${npmCmd} ${runCmd} watch-*`,
-            }),
-        ).toEqual([
-            { name: 'js', command: `${npmCmd} ${runCmd} watch-js` },
-            { name: 'css', command: `${npmCmd} ${runCmd} watch-css` },
-        ]);
-    });
-
-    it('uses existing command name as prefix to the wildcard match', () => {
-        readPkg.mockReturnValue({
-            scripts: {
-                'watch-js': '',
-                'watch-css': '',
-            },
-        });
-
-        expect(
-            parser.parse({
-                name: 'w:',
-                command: `${npmCmd} ${runCmd} watch-*`,
-            }),
-        ).toEqual([
-            { name: 'w:js', command: `${npmCmd} ${runCmd} watch-js` },
-            { name: 'w:css', command: `${npmCmd} ${runCmd} watch-css` },
-        ]);
-    });
-
-    it('allows negation', () => {
-        readPkg.mockReturnValue({
-            scripts: {
-                'lint:js': '',
-                'lint:ts': '',
-                'lint:fix:js': '',
-                'lint:fix:ts': '',
-            },
-        });
-
-        expect(parser.parse(createCommandInfo(`${npmCmd} ${runCmd} lint:*(!fix)`))).toEqual([
-            { name: 'js', command: `${npmCmd} ${runCmd} lint:js` },
-            { name: 'ts', command: `${npmCmd} ${runCmd} lint:ts` },
-        ]);
-    });
-
-    it('caches scripts upon calls', () => {
-        readPkg.mockReturnValue({});
-        parser.parse(createCommandInfo(`${npmCmd} run foo-*-baz qux`));
-        parser.parse(createCommandInfo(`${npmCmd} run foo-*-baz qux`));
-
-        expect(readPkg).toHaveBeenCalledTimes(1);
-    });
-});
diff --git a/src/command-parser/expand-npm-wildcard.ts b/src/command-parser/expand-npm-wildcard.ts
deleted file mode 100644
index dc55451b..00000000
--- a/src/command-parser/expand-npm-wildcard.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import fs from 'fs';
-import _ from 'lodash';
-
-import { CommandInfo } from '../command';
-import { CommandParser } from './command-parser';
-
-const OMISSION = /\(!([^)]+)\)/;
-
-/**
- * Finds wildcards in npm/yarn/pnpm/bun run commands and replaces them with all matching scripts in the
- * `package.json` file of the current directory.
- */
-export class ExpandNpmWildcard implements CommandParser {
-    static readPackage() {
-        try {
-            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
-            return JSON.parse(json);
-        } catch (e) {
-            return {};
-        }
-    }
-
-    private scripts?: string[];
-
-    constructor(private readonly readPackage = ExpandNpmWildcard.readPackage) {}
-
-    parse(commandInfo: CommandInfo) {
-        const [, npmCmd, runCmd, cmdName, args] =
-            commandInfo.command.match(/(node|npm|yarn|pnpm|bun) ((?:--)?run) (\S+)([^&]*)/) || [];
-        const wildcardPosition = (cmdName || '').indexOf('*');
-
-        // If the regex didn't match an npm script, or it has no wildcard,
-        // then we have nothing to do here
-        if (!cmdName || wildcardPosition === -1) {
-            return commandInfo;
-        }
-
-        if (!this.scripts) {
-            this.scripts = Object.keys(this.readPackage().scripts || {});
-        }
-
-        const omissionRegex = cmdName.match(OMISSION);
-        const cmdNameSansOmission = cmdName.replace(OMISSION, '');
-        const preWildcard = _.escapeRegExp(cmdNameSansOmission.slice(0, wildcardPosition));
-        const postWildcard = _.escapeRegExp(cmdNameSansOmission.slice(wildcardPosition + 1));
-        const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
-        // If 'commandInfo.name' doesn't match 'cmdName', this means a custom name
-        // has been specified and thus becomes the prefix (as described in the README).
-        const prefix = commandInfo.name !== cmdName ? commandInfo.name : '';
-
-        return this.scripts
-            .map((script) => {
-                const match = script.match(wildcardRegex);
-
-                if (omissionRegex) {
-                    const toOmit = script.match(new RegExp(omissionRegex[1]));
-
-                    if (toOmit) {
-                        return;
-                    }
-                }
-
-                if (match) {
-                    return {
-                        ...commandInfo,
-                        command: `${npmCmd} ${runCmd} ${script}${args}`,
-                        // Will use an empty command name if no prefix has been specified and
-                        // the wildcard match is empty, e.g. if `npm:watch-*` matches `npm run watch-`.
-                        name: prefix + match[1],
-                    };
-                }
-            })
-            .filter((commandInfo): commandInfo is CommandInfo => !!commandInfo);
-    }
-}
diff --git a/src/command-parser/expand-shortcut.spec.ts b/src/command-parser/expand-shortcut.spec.ts
new file mode 100644
index 00000000..5cbb8d3a
--- /dev/null
+++ b/src/command-parser/expand-shortcut.spec.ts
@@ -0,0 +1,41 @@
+import { CommandInfo } from '../command';
+import { ExpandShortcut } from './expand-shortcut';
+
+const parser = new ExpandShortcut();
+
+const createCommandInfo = (command: string, name = ''): CommandInfo => ({
+    name,
+    command,
+});
+
+it('returns same command if no prefix is present', () => {
+    const commandInfo = createCommandInfo('echo foo');
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+describe.each([
+    ['npm', 'npm run'],
+    ['yarn', 'yarn run'],
+    ['pnpm', 'pnpm run'],
+    ['bun', 'bun run'],
+    ['node', 'node --run'],
+    ['deno', 'deno task'],
+])(`with '%s:' prefix`, (prefix, command) => {
+    it(`expands to "${command} <script> <args>"`, () => {
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`, 'echo');
+        expect(parser.parse(commandInfo)).toEqual({
+            ...commandInfo,
+            name: 'echo',
+            command: `${command} foo -- bar`,
+        });
+    });
+
+    it('sets name to script name if none', () => {
+        const commandInfo = createCommandInfo(`${prefix}:foo -- bar`);
+        expect(parser.parse(commandInfo)).toEqual({
+            ...commandInfo,
+            name: 'foo',
+            command: `${command} foo -- bar`,
+        });
+    });
+});
diff --git a/src/command-parser/expand-shortcut.ts b/src/command-parser/expand-shortcut.ts
new file mode 100644
index 00000000..872bdc97
--- /dev/null
+++ b/src/command-parser/expand-shortcut.ts
@@ -0,0 +1,39 @@
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+
+/**
+ * Expands shortcuts according to the following table:
+ *
+ * | Syntax          | Expands to            |
+ * | --------------- | --------------------- |
+ * | `npm:<script>`  | `npm run <script>`    |
+ * | `pnpm:<script>` | `pnpm run <script>`   |
+ * | `yarn:<script>` | `yarn run <script>`   |
+ * | `bun:<script>`  | `bun run <script>`    |
+ * | `node:<script>` | `node --run <script>` |
+ * | `deno:<script>` | `deno task <script>`  |
+ */
+export class ExpandShortcut implements CommandParser {
+    parse(commandInfo: CommandInfo) {
+        const [, prefix, script, args] =
+            /^(npm|yarn|pnpm|bun|node|deno):(\S+)(.*)/.exec(commandInfo.command) || [];
+        if (!script) {
+            return commandInfo;
+        }
+
+        let command: string;
+        if (prefix === 'node') {
+            command = 'node --run';
+        } else if (prefix === 'deno') {
+            command = 'deno task';
+        } else {
+            command = `${prefix} run`;
+        }
+
+        return {
+            ...commandInfo,
+            name: commandInfo.name || script,
+            command: `${command} ${script}${args}`,
+        };
+    }
+}
diff --git a/src/command-parser/expand-wildcard.spec.ts b/src/command-parser/expand-wildcard.spec.ts
new file mode 100644
index 00000000..93cd58dd
--- /dev/null
+++ b/src/command-parser/expand-wildcard.spec.ts
@@ -0,0 +1,309 @@
+import fs from 'fs';
+
+import { CommandInfo } from '../command';
+import { ExpandWildcard } from './expand-wildcard';
+
+let parser: ExpandWildcard;
+let readPackage: jest.Mock;
+let readDeno: jest.Mock;
+
+const createCommandInfo = (command: string): CommandInfo => ({
+    command,
+    name: '',
+});
+
+beforeEach(() => {
+    readDeno = jest.fn();
+    readPackage = jest.fn();
+    parser = new ExpandWildcard(readDeno, readPackage);
+});
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+describe('ExpandWildcard#readDeno', () => {
+    it('can read deno', () => {
+        const expectedDeno = {
+            name: 'deno',
+            version: '1.14.0',
+        };
+        jest.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'deno.json') {
+                return JSON.stringify(expectedDeno);
+            }
+            return '';
+        });
+
+        const actualReadDeno = ExpandWildcard.readDeno();
+        expect(actualReadDeno).toEqual(expectedDeno);
+    });
+
+    it('can handle errors reading deno', () => {
+        jest.spyOn(fs, 'readFileSync').mockImplementation(() => {
+            throw new Error('Error reading deno');
+        });
+
+        expect(() => ExpandWildcard.readDeno()).not.toThrow();
+        expect(ExpandWildcard.readDeno()).toEqual({});
+    });
+});
+
+describe('ExpandWildcard#readPackage', () => {
+    it('can read package', () => {
+        const expectedPackage = {
+            name: 'concurrently',
+            version: '6.4.0',
+        };
+        jest.spyOn(fs, 'readFileSync').mockImplementation((path) => {
+            if (path === 'package.json') {
+                return JSON.stringify(expectedPackage);
+            }
+            return '';
+        });
+
+        const actualReadPackage = ExpandWildcard.readPackage();
+        expect(actualReadPackage).toEqual(expectedPackage);
+    });
+
+    it('can handle errors reading package', () => {
+        jest.spyOn(fs, 'readFileSync').mockImplementation(() => {
+            throw new Error('Error reading package');
+        });
+
+        expect(() => ExpandWildcard.readPackage()).not.toThrow();
+        expect(ExpandWildcard.readPackage()).toEqual({});
+    });
+});
+
+it('returns same command if not an npm run command', () => {
+    const commandInfo = createCommandInfo('npm test');
+
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('returns same command if not a deno task command', () => {
+    const commandInfo = createCommandInfo('deno run');
+
+    expect(readDeno).not.toHaveBeenCalled();
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('returns same command if no wildcard present', () => {
+    const commandInfo = createCommandInfo('npm run foo bar');
+
+    expect(readPackage).not.toHaveBeenCalled();
+    expect(parser.parse(commandInfo)).toBe(commandInfo);
+});
+
+it('expands to nothing if no scripts exist in package.json', () => {
+    readPackage.mockReturnValue({});
+
+    expect(parser.parse(createCommandInfo('npm run foo-*-baz qux'))).toEqual([]);
+});
+
+it('expands to nothing if no tasks exist in deno.json and no scripts exist in package.json', () => {
+    readDeno.mockReturnValue({});
+    readPackage.mockReturnValue({});
+
+    expect(parser.parse(createCommandInfo('deno task foo-*-baz qux'))).toEqual([]);
+});
+
+describe.each(['npm run', 'yarn run', 'pnpm run', 'bun run', 'node --run'])(
+    `with a '%s' prefix`,
+    (command) => {
+        it('expands to all scripts matching pattern', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'foo-bar-baz': '',
+                    'foo--baz': '',
+                },
+            });
+
+            expect(parser.parse(createCommandInfo(`${command} foo-*-baz qux`))).toEqual([
+                { name: 'bar', command: `${command} foo-bar-baz qux` },
+                { name: '', command: `${command} foo--baz qux` },
+            ]);
+        });
+
+        it('uses wildcard match of script as command name', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'watch-js': '',
+                    'watch-css': '',
+                },
+            });
+
+            expect(
+                parser.parse({
+                    name: '',
+                    command: `${command} watch-*`,
+                }),
+            ).toEqual([
+                { name: 'js', command: `${command} watch-js` },
+                { name: 'css', command: `${command} watch-css` },
+            ]);
+        });
+
+        it('uses existing command name as prefix to the wildcard match', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'watch-js': '',
+                    'watch-css': '',
+                },
+            });
+
+            expect(
+                parser.parse({
+                    name: 'w:',
+                    command: `${command} watch-*`,
+                }),
+            ).toEqual([
+                { name: 'w:js', command: `${command} watch-js` },
+                { name: 'w:css', command: `${command} watch-css` },
+            ]);
+        });
+
+        it('allows negation', () => {
+            readPackage.mockReturnValue({
+                scripts: {
+                    'lint:js': '',
+                    'lint:ts': '',
+                    'lint:fix:js': '',
+                    'lint:fix:ts': '',
+                },
+            });
+
+            expect(parser.parse(createCommandInfo(`${command} lint:*(!fix)`))).toEqual([
+                { name: 'js', command: `${command} lint:js` },
+                { name: 'ts', command: `${command} lint:ts` },
+            ]);
+        });
+
+        it('caches scripts upon calls', () => {
+            readPackage.mockReturnValue({});
+
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+
+            expect(readPackage).toHaveBeenCalledTimes(1);
+        });
+
+        it("doesn't read deno.json", () => {
+            readPackage.mockReturnValue({});
+
+            parser.parse(createCommandInfo(`${command} foo-*-baz qux`));
+
+            expect(readDeno).not.toHaveBeenCalled();
+        });
+    },
+);
+
+describe(`with a 'deno task' prefix`, () => {
+    it('expands to all scripts matching pattern', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'foo-bar-baz': '',
+                'foo--baz': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'foo-foo-baz': '',
+            },
+        });
+
+        expect(parser.parse(createCommandInfo(`deno task foo-*-baz qux`))).toEqual([
+            { name: 'bar', command: `deno task foo-bar-baz qux` },
+            { name: '', command: `deno task foo--baz qux` },
+            { name: 'foo', command: `deno task foo-foo-baz qux` },
+        ]);
+    });
+
+    it('uses wildcard match of script as command name', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+
+        expect(
+            parser.parse({
+                name: '',
+                command: `deno task watch-*`,
+            }),
+        ).toEqual([
+            { name: 'sass', command: `deno task watch-sass` },
+            { name: 'js', command: `deno task watch-js` },
+            { name: 'css', command: `deno task watch-css` },
+        ]);
+    });
+
+    it('uses existing command name as prefix to the wildcard match', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'watch-sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'watch-js': '',
+                'watch-css': '',
+            },
+        });
+
+        expect(
+            parser.parse({
+                name: 'w:',
+                command: `deno task watch-*`,
+            }),
+        ).toEqual([
+            { name: 'w:sass', command: `deno task watch-sass` },
+            { name: 'w:js', command: `deno task watch-js` },
+            { name: 'w:css', command: `deno task watch-css` },
+        ]);
+    });
+
+    it('allows negation', () => {
+        readDeno.mockReturnValue({
+            tasks: {
+                'lint:sass': '',
+                'lint:fix:sass': '',
+            },
+        });
+        readPackage.mockReturnValue({
+            scripts: {
+                'lint:js': '',
+                'lint:ts': '',
+                'lint:fix:js': '',
+                'lint:fix:ts': '',
+            },
+        });
+
+        expect(parser.parse(createCommandInfo(`deno task lint:*(!fix)`))).toEqual([
+            { name: 'sass', command: `deno task lint:sass` },
+            { name: 'js', command: `deno task lint:js` },
+            { name: 'ts', command: `deno task lint:ts` },
+        ]);
+    });
+
+    it('caches scripts upon calls', () => {
+        readDeno.mockReturnValue({});
+        readPackage.mockReturnValue({});
+
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
+        parser.parse(createCommandInfo(`deno task foo-*-baz qux`));
+
+        expect(readDeno).toHaveBeenCalledTimes(1);
+        expect(readPackage).toHaveBeenCalledTimes(1);
+    });
+});
diff --git a/src/command-parser/expand-wildcard.ts b/src/command-parser/expand-wildcard.ts
new file mode 100644
index 00000000..810750f3
--- /dev/null
+++ b/src/command-parser/expand-wildcard.ts
@@ -0,0 +1,110 @@
+import fs from 'fs';
+import _ from 'lodash';
+
+import { CommandInfo } from '../command';
+import { CommandParser } from './command-parser';
+
+// Matches a negative filter surrounded by '(!' and ')'.
+const OMISSION = /\(!([^)]+)\)/;
+
+/**
+ * Finds wildcards in 'npm/yarn/pnpm/bun run', 'node --run' and 'deno task'
+ * commands and replaces them with all matching scripts in the `package.json`
+ * and `deno.json` files of the current directory.
+ */
+export class ExpandWildcard implements CommandParser {
+    static readDeno() {
+        try {
+            const json = fs.readFileSync('deno.json', { encoding: 'utf-8' });
+            return JSON.parse(json);
+        } catch (e) {
+            return {};
+        }
+    }
+
+    static readPackage() {
+        try {
+            const json = fs.readFileSync('package.json', { encoding: 'utf-8' });
+            return JSON.parse(json);
+        } catch (e) {
+            return {};
+        }
+    }
+
+    private packageScripts?: string[];
+    private denoTasks?: string[];
+
+    constructor(
+        private readonly readDeno = ExpandWildcard.readDeno,
+        private readonly readPackage = ExpandWildcard.readPackage,
+    ) {}
+
+    private relevantScripts(command: string): string[] {
+        if (!this.packageScripts) {
+            this.packageScripts = Object.keys(this.readPackage().scripts || {});
+        }
+
+        if (command === 'deno task') {
+            if (!this.denoTasks) {
+                // If Deno tries to run a task that doesn't exist,
+                // it can fall back to running a script with the same name.
+                // Therefore, the actual list of tasks is the union of the tasks and scripts.
+                this.denoTasks = [
+                    ...Object.keys(this.readDeno().tasks || {}),
+                    ...this.packageScripts,
+                ];
+            }
+
+            return this.denoTasks;
+        }
+
+        return this.packageScripts;
+    }
+
+    parse(commandInfo: CommandInfo) {
+        // We expect one of the following patterns:
+        // - <npm|yarn|pnpm|bun> run <script> [args]
+        // - node --run <script> [args]
+        // - deno task <script> [args]
+        const [, command, scriptGlob, args] =
+            /((?:npm|yarn|pnpm|bun) (?:run)|node --run|deno task) (\S+)([^&]*)/.exec(
+                commandInfo.command,
+            ) || [];
+
+        const wildcardPosition = (scriptGlob || '').indexOf('*');
+
+        // If the regex didn't match an npm script, or it has no wildcard,
+        // then we have nothing to do here
+        if (wildcardPosition === -1) {
+            return commandInfo;
+        }
+
+        const [, omission] = OMISSION.exec(scriptGlob) || [];
+        const scriptGlobSansOmission = scriptGlob.replace(OMISSION, '');
+        const preWildcard = _.escapeRegExp(scriptGlobSansOmission.slice(0, wildcardPosition));
+        const postWildcard = _.escapeRegExp(scriptGlobSansOmission.slice(wildcardPosition + 1));
+        const wildcardRegex = new RegExp(`^${preWildcard}(.*?)${postWildcard}$`);
+        // If 'commandInfo.name' doesn't match 'scriptGlob', this means a custom name
+        // has been specified and thus becomes the prefix (as described in the README).
+        const prefix = commandInfo.name !== scriptGlob ? commandInfo.name : '';
+
+        return this.relevantScripts(command)
+            .map((script) => {
+                if (omission && RegExp(omission).test(script)) {
+                    return;
+                }
+
+                const [, match] = wildcardRegex.exec(script) || [];
+                if (match !== undefined) {
+                    return {
+                        ...commandInfo,
+                        command: `${command} ${script}${args}`,
+                        // Will use an empty command name if no prefix has been specified and
+                        // the wildcard match is empty, e.g. if `npm:watch-*` matches `npm run watch-`.
+                        name: prefix + match,
+                    };
+                }
+            })
+            .filter((commandInfo): commandInfo is CommandInfo => !!commandInfo);
+    }
+}
diff --git a/src/concurrently.ts b/src/concurrently.ts
index e507343d..30a9fbfe 100644
--- a/src/concurrently.ts
+++ b/src/concurrently.ts
@@ -14,8 +14,8 @@ import {
 } from './command';
 import { CommandParser } from './command-parser/command-parser';
 import { ExpandArguments } from './command-parser/expand-arguments';
-import { ExpandNpmShortcut } from './command-parser/expand-npm-shortcut';
-import { ExpandNpmWildcard } from './command-parser/expand-npm-wildcard';
+import { ExpandShortcut } from './command-parser/expand-shortcut';
+import { ExpandWildcard } from './command-parser/expand-wildcard';
 import { StripQuotes } from './command-parser/strip-quotes';
 import { CompletionListener, SuccessCondition } from './completion-listener';
 import { FlowController } from './flow-control/flow-controller';
@@ -175,8 +175,8 @@ export function concurrently(
 
     const commandParsers: CommandParser[] = [
         new StripQuotes(),
-        new ExpandNpmShortcut(),
-        new ExpandNpmWildcard(),
+        new ExpandShortcut(),
+        new ExpandWildcard(),
     ];
 
     if (options.additionalArguments) {