├── Archive.zip
├── Pronounce 2.3.zip
├── Pronounce2.5.1.zip
├── README.md
├── browser-polyfill.js
├── icons
├── .DS_Store
└── border-48.png
├── index.html
├── manifest.json
├── newtab.html
├── newtab.js
├── options.html
├── options.js
├── package-lock.json
└── pronounce.js
/Archive.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tryhardfifi/pronounce/f545675f417da0932a5bae15a0396b0e98d40f7c/Archive.zip
--------------------------------------------------------------------------------
/Pronounce 2.3.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tryhardfifi/pronounce/f545675f417da0932a5bae15a0396b0e98d40f7c/Pronounce 2.3.zip
--------------------------------------------------------------------------------
/Pronounce2.5.1.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tryhardfifi/pronounce/f545675f417da0932a5bae15a0396b0e98d40f7c/Pronounce2.5.1.zip
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Double-click pronounce: improve your pronounciation for any language 🗣
2 |
3 | Never doubt how to pronounce a word. Double-click it and your browser will read it out loud for you! (Works on Firefox and Chrome).
4 |
5 | Some people use double click to select a word and to then expand the selection to other words, as it would be terrible for you to listen to any selection out loud, double click pronounce will only read out loud when you double-click a single word.
6 |
7 | ## Features
8 | - ✅ Works on Firefox
9 | - ✅ Works on Chrome
10 | - ✅ Language locale selection
11 | - ✅ Toggle on/off
12 | - ✅ Blacklist to turn off in certain webpages
13 |
14 | Click here to see all locales supported:
15 |
16 |
17 |
18 | - "en-US"
19 | - "it-IT"
20 | - "sv-SE"
21 | - "fr-CA"
22 | - "de-DE"
23 | - "he-IL"
24 | - "id-ID"
25 | - "en-GB"
26 | - "es-AR"
27 | - "nl-BE"
28 | - "en-scotland"
29 | - "en-US"
30 | - "ro-RO"
31 | - "pt-PT"
32 | - "es-ES"
33 | - "es-MX"
34 | - "th-TH"
35 | - "en-AU"
36 | - "ja-JP"
37 | - "sk-SK"
38 | - "hi-IN"
39 | - "it-IT"
40 | - "pt-BR"
41 | - "ar-SA"
42 | - "hu-HU"
43 | - "zh-TW"
44 | - "el-GR"
45 | - "ru-RU"
46 | - "en-IE"
47 | - "es-ES"
48 | - "nb-NO"
49 | - "es-MX"
50 | - "en-IN"
51 | - "en-US"
52 | - "da-DK"
53 | - "fi-FI"
54 | - "zh-HK"
55 | - "en-ZA"
56 | - "fr-FR"
57 | - "zh-CN"
58 | - "en-IN"
59 | - "en-US"
60 | - "nl-NL"
61 | - "tr-TR"
62 | - "ko-KR"
63 | - "ru-RU"
64 | - "pl-PL"
65 | - "cs-CZ"
66 |
67 |
68 | }
862 | * A Proxy object for the given method, which invokes the given wrapper
863 | * method in its place.
864 | */
865 |
866 |
867 | const wrapMethod = (target, method, wrapper) => {
868 | return new Proxy(method, {
869 | apply(targetMethod, thisObj, args) {
870 | return wrapper.call(thisObj, target, ...args);
871 | }
872 |
873 | });
874 | };
875 |
876 | let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
877 | /**
878 | * Wraps an object in a Proxy which intercepts and wraps certain methods
879 | * based on the given `wrappers` and `metadata` objects.
880 | *
881 | * @param {object} target
882 | * The target object to wrap.
883 | *
884 | * @param {object} [wrappers = {}]
885 | * An object tree containing wrapper functions for special cases. Any
886 | * function present in this object tree is called in place of the
887 | * method in the same location in the `target` object tree. These
888 | * wrapper methods are invoked as described in {@see wrapMethod}.
889 | *
890 | * @param {object} [metadata = {}]
891 | * An object tree containing metadata used to automatically generate
892 | * Promise-based wrapper functions for asynchronous. Any function in
893 | * the `target` object tree which has a corresponding metadata object
894 | * in the same location in the `metadata` tree is replaced with an
895 | * automatically-generated wrapper function, as described in
896 | * {@see wrapAsyncFunction}
897 | *
898 | * @returns {Proxy}
899 | */
900 |
901 | const wrapObject = (target, wrappers = {}, metadata = {}) => {
902 | let cache = Object.create(null);
903 | let handlers = {
904 | has(proxyTarget, prop) {
905 | return prop in target || prop in cache;
906 | },
907 |
908 | get(proxyTarget, prop, receiver) {
909 | if (prop in cache) {
910 | return cache[prop];
911 | }
912 |
913 | if (!(prop in target)) {
914 | return undefined;
915 | }
916 |
917 | let value = target[prop];
918 |
919 | if (typeof value === "function") {
920 | // This is a method on the underlying object. Check if we need to do
921 | // any wrapping.
922 | if (typeof wrappers[prop] === "function") {
923 | // We have a special-case wrapper for this method.
924 | value = wrapMethod(target, target[prop], wrappers[prop]);
925 | } else if (hasOwnProperty(metadata, prop)) {
926 | // This is an async method that we have metadata for. Create a
927 | // Promise wrapper for it.
928 | let wrapper = wrapAsyncFunction(prop, metadata[prop]);
929 | value = wrapMethod(target, target[prop], wrapper);
930 | } else {
931 | // This is a method that we don't know or care about. Return the
932 | // original method, bound to the underlying object.
933 | value = value.bind(target);
934 | }
935 | } else if (typeof value === "object" && value !== null && (hasOwnProperty(wrappers, prop) || hasOwnProperty(metadata, prop))) {
936 | // This is an object that we need to do some wrapping for the children
937 | // of. Create a sub-object wrapper for it with the appropriate child
938 | // metadata.
939 | value = wrapObject(value, wrappers[prop], metadata[prop]);
940 | } else if (hasOwnProperty(metadata, "*")) {
941 | // Wrap all properties in * namespace.
942 | value = wrapObject(value, wrappers[prop], metadata["*"]);
943 | } else {
944 | // We don't need to do any wrapping for this property,
945 | // so just forward all access to the underlying object.
946 | Object.defineProperty(cache, prop, {
947 | configurable: true,
948 | enumerable: true,
949 |
950 | get() {
951 | return target[prop];
952 | },
953 |
954 | set(value) {
955 | target[prop] = value;
956 | }
957 |
958 | });
959 | return value;
960 | }
961 |
962 | cache[prop] = value;
963 | return value;
964 | },
965 |
966 | set(proxyTarget, prop, value, receiver) {
967 | if (prop in cache) {
968 | cache[prop] = value;
969 | } else {
970 | target[prop] = value;
971 | }
972 |
973 | return true;
974 | },
975 |
976 | defineProperty(proxyTarget, prop, desc) {
977 | return Reflect.defineProperty(cache, prop, desc);
978 | },
979 |
980 | deleteProperty(proxyTarget, prop) {
981 | return Reflect.deleteProperty(cache, prop);
982 | }
983 |
984 | }; // Per contract of the Proxy API, the "get" proxy handler must return the
985 | // original value of the target if that value is declared read-only and
986 | // non-configurable. For this reason, we create an object with the
987 | // prototype set to `target` instead of using `target` directly.
988 | // Otherwise we cannot return a custom object for APIs that
989 | // are declared read-only and non-configurable, such as `chrome.devtools`.
990 | //
991 | // The proxy handlers themselves will still use the original `target`
992 | // instead of the `proxyTarget`, so that the methods and properties are
993 | // dereferenced via the original targets.
994 |
995 | let proxyTarget = Object.create(target);
996 | return new Proxy(proxyTarget, handlers);
997 | };
998 | /**
999 | * Creates a set of wrapper functions for an event object, which handles
1000 | * wrapping of listener functions that those messages are passed.
1001 | *
1002 | * A single wrapper is created for each listener function, and stored in a
1003 | * map. Subsequent calls to `addListener`, `hasListener`, or `removeListener`
1004 | * retrieve the original wrapper, so that attempts to remove a
1005 | * previously-added listener work as expected.
1006 | *
1007 | * @param {DefaultWeakMap} wrapperMap
1008 | * A DefaultWeakMap object which will create the appropriate wrapper
1009 | * for a given listener function when one does not exist, and retrieve
1010 | * an existing one when it does.
1011 | *
1012 | * @returns {object}
1013 | */
1014 |
1015 |
1016 | const wrapEvent = wrapperMap => ({
1017 | addListener(target, listener, ...args) {
1018 | target.addListener(wrapperMap.get(listener), ...args);
1019 | },
1020 |
1021 | hasListener(target, listener) {
1022 | return target.hasListener(wrapperMap.get(listener));
1023 | },
1024 |
1025 | removeListener(target, listener) {
1026 | target.removeListener(wrapperMap.get(listener));
1027 | }
1028 |
1029 | }); // Keep track if the deprecation warning has been logged at least once.
1030 |
1031 |
1032 | let loggedSendResponseDeprecationWarning = false;
1033 | const onMessageWrappers = new DefaultWeakMap(listener => {
1034 | if (typeof listener !== "function") {
1035 | return listener;
1036 | }
1037 | /**
1038 | * Wraps a message listener function so that it may send responses based on
1039 | * its return value, rather than by returning a sentinel value and calling a
1040 | * callback. If the listener function returns a Promise, the response is
1041 | * sent when the promise either resolves or rejects.
1042 | *
1043 | * @param {*} message
1044 | * The message sent by the other end of the channel.
1045 | * @param {object} sender
1046 | * Details about the sender of the message.
1047 | * @param {function(*)} sendResponse
1048 | * A callback which, when called with an arbitrary argument, sends
1049 | * that value as a response.
1050 | * @returns {boolean}
1051 | * True if the wrapped listener returned a Promise, which will later
1052 | * yield a response. False otherwise.
1053 | */
1054 |
1055 |
1056 | return function onMessage(message, sender, sendResponse) {
1057 | let didCallSendResponse = false;
1058 | let wrappedSendResponse;
1059 | let sendResponsePromise = new Promise(resolve => {
1060 | wrappedSendResponse = function (response) {
1061 | if (!loggedSendResponseDeprecationWarning) {
1062 | console.warn(SEND_RESPONSE_DEPRECATION_WARNING, new Error().stack);
1063 | loggedSendResponseDeprecationWarning = true;
1064 | }
1065 |
1066 | didCallSendResponse = true;
1067 | resolve(response);
1068 | };
1069 | });
1070 | let result;
1071 |
1072 | try {
1073 | result = listener(message, sender, wrappedSendResponse);
1074 | } catch (err) {
1075 | result = Promise.reject(err);
1076 | }
1077 |
1078 | const isResultThenable = result !== true && isThenable(result); // If the listener didn't returned true or a Promise, or called
1079 | // wrappedSendResponse synchronously, we can exit earlier
1080 | // because there will be no response sent from this listener.
1081 |
1082 | if (result !== true && !isResultThenable && !didCallSendResponse) {
1083 | return false;
1084 | } // A small helper to send the message if the promise resolves
1085 | // and an error if the promise rejects (a wrapped sendMessage has
1086 | // to translate the message into a resolved promise or a rejected
1087 | // promise).
1088 |
1089 |
1090 | const sendPromisedResult = promise => {
1091 | promise.then(msg => {
1092 | // send the message value.
1093 | sendResponse(msg);
1094 | }, error => {
1095 | // Send a JSON representation of the error if the rejected value
1096 | // is an instance of error, or the object itself otherwise.
1097 | let message;
1098 |
1099 | if (error && (error instanceof Error || typeof error.message === "string")) {
1100 | message = error.message;
1101 | } else {
1102 | message = "An unexpected error occurred";
1103 | }
1104 |
1105 | sendResponse({
1106 | __mozWebExtensionPolyfillReject__: true,
1107 | message
1108 | });
1109 | }).catch(err => {
1110 | // Print an error on the console if unable to send the response.
1111 | console.error("Failed to send onMessage rejected reply", err);
1112 | });
1113 | }; // If the listener returned a Promise, send the resolved value as a
1114 | // result, otherwise wait the promise related to the wrappedSendResponse
1115 | // callback to resolve and send it as a response.
1116 |
1117 |
1118 | if (isResultThenable) {
1119 | sendPromisedResult(result);
1120 | } else {
1121 | sendPromisedResult(sendResponsePromise);
1122 | } // Let Chrome know that the listener is replying.
1123 |
1124 |
1125 | return true;
1126 | };
1127 | });
1128 |
1129 | const wrappedSendMessageCallback = ({
1130 | reject,
1131 | resolve
1132 | }, reply) => {
1133 | if (extensionAPIs.runtime.lastError) {
1134 | // Detect when none of the listeners replied to the sendMessage call and resolve
1135 | // the promise to undefined as in Firefox.
1136 | // See https://github.com/mozilla/webextension-polyfill/issues/130
1137 | if (extensionAPIs.runtime.lastError.message === CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) {
1138 | resolve();
1139 | } else {
1140 | reject(extensionAPIs.runtime.lastError);
1141 | }
1142 | } else if (reply && reply.__mozWebExtensionPolyfillReject__) {
1143 | // Convert back the JSON representation of the error into
1144 | // an Error instance.
1145 | reject(new Error(reply.message));
1146 | } else {
1147 | resolve(reply);
1148 | }
1149 | };
1150 |
1151 | const wrappedSendMessage = (name, metadata, apiNamespaceObj, ...args) => {
1152 | if (args.length < metadata.minArgs) {
1153 | throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`);
1154 | }
1155 |
1156 | if (args.length > metadata.maxArgs) {
1157 | throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`);
1158 | }
1159 |
1160 | return new Promise((resolve, reject) => {
1161 | const wrappedCb = wrappedSendMessageCallback.bind(null, {
1162 | resolve,
1163 | reject
1164 | });
1165 | args.push(wrappedCb);
1166 | apiNamespaceObj.sendMessage(...args);
1167 | });
1168 | };
1169 |
1170 | const staticWrappers = {
1171 | runtime: {
1172 | onMessage: wrapEvent(onMessageWrappers),
1173 | onMessageExternal: wrapEvent(onMessageWrappers),
1174 | sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
1175 | minArgs: 1,
1176 | maxArgs: 3
1177 | })
1178 | },
1179 | tabs: {
1180 | sendMessage: wrappedSendMessage.bind(null, "sendMessage", {
1181 | minArgs: 2,
1182 | maxArgs: 3
1183 | })
1184 | }
1185 | };
1186 | const settingMetadata = {
1187 | clear: {
1188 | minArgs: 1,
1189 | maxArgs: 1
1190 | },
1191 | get: {
1192 | minArgs: 1,
1193 | maxArgs: 1
1194 | },
1195 | set: {
1196 | minArgs: 1,
1197 | maxArgs: 1
1198 | }
1199 | };
1200 | apiMetadata.privacy = {
1201 | network: {
1202 | "*": settingMetadata
1203 | },
1204 | services: {
1205 | "*": settingMetadata
1206 | },
1207 | websites: {
1208 | "*": settingMetadata
1209 | }
1210 | };
1211 | return wrapObject(extensionAPIs, staticWrappers, apiMetadata);
1212 | };
1213 |
1214 | if (typeof chrome != "object" || !chrome || !chrome.runtime || !chrome.runtime.id) {
1215 | throw new Error("This script should only be loaded in a browser extension.");
1216 | } // The build process adds a UMD wrapper around this file, which makes the
1217 | // `module` variable available.
1218 |
1219 |
1220 | module.exports = wrapAPIs(chrome);
1221 | } else {
1222 | module.exports = browser;
1223 | }
1224 | });
1225 | //# sourceMappingURL=browser-polyfill.js.map
1226 |
--------------------------------------------------------------------------------
/icons/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tryhardfifi/pronounce/f545675f417da0932a5bae15a0396b0e98d40f7c/icons/.DS_Store
--------------------------------------------------------------------------------
/icons/border-48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/tryhardfifi/pronounce/f545675f417da0932a5bae15a0396b0e98d40f7c/icons/border-48.png
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | "],
22 | "js": ["browser-polyfill.js","pronounce.js"]
23 | }
24 | ],
25 |
26 | "options_ui": {
27 | "page": "options.html"
28 | },
29 |
30 | "permissions": ["tabs","storage", "management"],
31 | "chrome_url_overrides" : {
32 | "newtab": "newtab.html"
33 | },
34 |
35 |
36 | "browser_specific_settings": {
37 | "gecko": {
38 | "id": "{f8716d82-2c5c-430d-b783-5473310342cf}"
39 | }
40 | },
41 | "browser_action": {
42 | "default_icon": {
43 | "32": "icons/border-48.png"
44 | },
45 |
46 | "default_title": "Pronounce",
47 | "default_popup": "options.html"
48 | }
49 |
50 |
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/newtab.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Pronounce:
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
83 |
84 |
--------------------------------------------------------------------------------
/newtab.js:
--------------------------------------------------------------------------------
1 | /*
2 | * Generate HTML List From JavaScript Array
3 | *
4 | * @uri https://getbutterfly.com/generate-html-list-from-javascript-array/
5 | */
6 | function makeList(listData) {
7 | // Establish the array which acts as a data source for the list
8 | console.log(listData);
9 | // Make a container element for the list
10 | listContainer = document.getElementById("1");
11 | wordContainer = document.getElementById("2");
12 | counter = document.getElementById("3");
13 | // Make the list
14 | listElement = document.createElement("ul");
15 |
16 | document.getElementsByTagName("body")[0].appendChild(wordContainer);
17 | numberOfListItems = listData.length;
18 | counter.innerHTML = numberOfListItems;
19 | var rand = listData[Math.floor(Math.random() * numberOfListItems)];
20 | wordContainer.innerHTML = rand;
21 |
22 | document.getElementsByTagName("body")[0].appendChild(listContainer);
23 | listContainer.appendChild(listElement);
24 | for (i = 0; i < numberOfListItems; ++i) {
25 | // create an item for each one
26 | listItem = document.createElement("li");
27 |
28 | // Add the item text
29 | listItem.innerHTML = listData[i];
30 |
31 | // Add listItem to the listElement
32 | listElement.appendChild(listItem);
33 | }
34 | }
35 |
36 | async function setList(result) {
37 | if (list != null) {
38 | list = JSON.parse(result.list);
39 | } else {
40 | list = [];
41 | }
42 | makeList(list);
43 | }
44 |
45 | function onError(error) {}
46 | let list = browser.storage.sync.get("list");
47 | list.then(setList, onError);
48 | let a = document.getElementById("my-manifest-placeholder");
49 | console.log(a);
50 | const stringManifest = JSON.stringify(myDynamicManifest);
51 | const blob = new Blob([stringManifest], { type: "application/json" });
52 | const manifestURL = URL.createObjectURL(blob);
53 | document
54 | .querySelector("#my-manifest-placeholder")
55 | .setAttribute("href", manifestURL);
56 |
--------------------------------------------------------------------------------
/options.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |