diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac29147..a0ca552 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,6 @@
+# 0.9.7
+* Add `extensionFromMime` utility function.
+
 # 0.9.6+3
 
 * Change the mime type for Dart source from `application/dart` to `text/x-dart`.
diff --git a/lib/src/default_extension_map.dart b/lib/src/default_extension_map.dart
index c7add48..d951b23 100644
--- a/lib/src/default_extension_map.dart
+++ b/lib/src/default_extension_map.dart
@@ -4,8 +4,7 @@
 
 library mime.extension_map;
 
-// TODO(ajohnsen): Use const map once Issue 7559 is fixed.
-final Map<String, String> defaultExtensionMap = <String, String>{
+const Map<String, String> defaultExtensionMap = <String, String>{
   '123': 'application/vnd.lotus-1-2-3',
   '3dml': 'text/vnd.in3d.3dml',
   '3ds': 'image/x-3ds',
diff --git a/lib/src/mime_type.dart b/lib/src/mime_type.dart
index 84ac306..2894052 100644
--- a/lib/src/mime_type.dart
+++ b/lib/src/mime_type.dart
@@ -25,6 +25,19 @@
 String lookupMimeType(String path, {List<int> headerBytes}) =>
     _globalResolver.lookup(path, headerBytes: headerBytes);
 
+/// Returns the extension for the given MIME type.
+///
+/// If there are multiple extensions for [mime], return the first occurrence in
+/// the map. If there are no extensions for [mime], return [mime].
+String extensionFromMime(String mime) {
+  for (final key in defaultExtensionMap.keys) {
+    if (defaultExtensionMap[key].toLowerCase() == mime.toLowerCase()) {
+      return key;
+    }
+  }
+  return mime;
+}
+
 /// MIME-type resolver class, used to customize the lookup of mime-types.
 class MimeTypeResolver {
   final Map<String, String> _extensionMap = {};
diff --git a/pubspec.yaml b/pubspec.yaml
index b0c21b3..16c6876 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: mime
-version: 0.9.7-dev
+version: 0.9.7
 
 description: >-
   Utilities for handling media (MIME) types, including determining a type from
diff --git a/test/mime_type_test.dart b/test/mime_type_test.dart
index 9d02772..7f9169c 100644
--- a/test/mime_type_test.dart
+++ b/test/mime_type_test.dart
@@ -123,4 +123,22 @@
 
     expect(defaultMagicNumbersMaxLength, actualMaxBytes);
   });
+
+  group('extensionFromMime', () {
+    test('returns match for mime with single extension', () {
+      expect(extensionFromMime('application/json'), equals('json'));
+      expect(extensionFromMime('application/java-archive'), equals('jar'));
+    });
+
+    test('returns first match for mime with multiple extensions', () {
+      expect(extensionFromMime('text/html'), equals('htm'));
+      expect(extensionFromMime('application/x-cbr'), equals('cb7'));
+    });
+
+    test('returns inputted string for unrecognized mime', () {
+      expect(
+          extensionFromMime('unrecognized_mime'), equals('unrecognized_mime'));
+      expect(extensionFromMime('i/am/not/a/mime'), equals('i/am/not/a/mime'));
+    });
+  });
 }
