RegExpA regex for matching note strings in scientific notation.
6 |ObjectParse a note name in scientific notation an return it's components, 9 | and some numeric properties including midi number and frequency.
10 |StringCreate a string from a parsed object or step, alteration, octave parameters
IntegerGet midi of a note
16 |FloatGet freq of a note in hertzs (in a well tempered 440Hz A4)
19 |RegExp
25 | A regex for matching note strings in scientific notation.
26 |
27 | **Kind**: global function
28 | **Returns**: RegExp - the regexp used to parse the note name
29 |
30 | The note string should have the form `letter[accidentals][octave][element]`
31 | where:
32 |
33 | - letter: (Required) is a letter from A to G either upper or lower case
34 | - accidentals: (Optional) can be one or more `b` (flats), `#` (sharps) or `x` (double sharps).
35 | They can NOT be mixed.
36 | - octave: (Optional) a positive or negative integer
37 | - element: (Optional) additionally anything after the duration is considered to
38 | be the element name (for example: 'C2 dorian')
39 |
40 | The executed regex contains (by array index):
41 |
42 | - 0: the complete string
43 | - 1: the note letter
44 | - 2: the optional accidentals
45 | - 3: the optional octave
46 | - 4: the rest of the string (trimmed)
47 | **Example**
48 | ```js
49 | var parser = require('note-parser')
50 | parser.regex.exec('c#4')
51 | // => ['c#4', 'c', '#', '4', '']
52 | parser.regex.exec('c#4 major')
53 | // => ['c#4major', 'c', '#', '4', 'major']
54 | parser.regex().exec('CMaj7')
55 | // => ['CMaj7', 'C', '', '', 'Maj7']
56 | ```
57 |
58 |
59 | ## parse(note, isTonic, tunning) ⇒ Object
60 | Parse a note name in scientific notation an return it's components,
61 | and some numeric properties including midi number and frequency.
62 |
63 | **Kind**: global function
64 | **Returns**: Object - the parsed note name or null if not a valid note
65 |
66 | The parsed note name object will ALWAYS contains:
67 | - letter: the uppercase letter of the note
68 | - acc: the accidentals of the note (only sharps or flats)
69 | - pc: the pitch class (letter + acc)
70 | - step: s a numeric representation of the letter. It's an integer from 0 to 6
71 | where 0 = C, 1 = D ... 6 = B
72 | - alt: a numeric representation of the accidentals. 0 means no alteration,
73 | positive numbers are for sharps and negative for flats
74 | - chroma: a numeric representation of the pitch class. It's like midi for
75 | pitch classes. 0 = C, 1 = C#, 2 = D ... 11 = B. Can be used to find enharmonics
76 | since, for example, chroma of 'Cb' and 'B' are both 11
77 |
78 | If the note has octave, the parser object will contain:
79 | - oct: the octave number (as integer)
80 | - midi: the midi number
81 | - freq: the frequency (using tuning parameter as base)
82 |
83 | If the parameter `isTonic` is set to true, the parsed object will contain:
84 | - tonicOf: the rest of the string that follows note name (left and right trimmed)
85 |
86 | | Param | Type | Description |
87 | | --- | --- | --- |
88 | | note | String | the note string to be parsed |
89 | | isTonic | Boolean | true the strings it's supposed to contain a note number and some category (for example an scale: 'C# major'). It's false by default, but when true, en extra tonicOf property is returned with the category ('major') |
90 | | tunning | Float | The frequency of A4 note to calculate frequencies. By default it 440. |
91 |
92 | **Example**
93 | ```js
94 | var parse = require('note-parser').parse
95 | parse('Cb4')
96 | // => { letter: 'C', acc: 'b', pc: 'Cb', step: 0, alt: -1, chroma: -1,
97 | oct: 4, midi: 59, freq: 246.94165062806206 }
98 | // if no octave, no midi, no freq
99 | parse('fx')
100 | // => { letter: 'F', acc: '##', pc: 'F##', step: 3, alt: 2, chroma: 7 })
101 | ```
102 |
103 |
104 | ## build(obj) ⇒ String
105 | Create a string from a parsed object or `step, alteration, octave` parameters
106 |
107 | **Kind**: global function
108 | **Returns**: String - a note string or null if not valid parameters
109 | **Since**: 1.2
110 |
111 | | Param | Type | Description |
112 | | --- | --- | --- |
113 | | obj | Object | the parsed data object |
114 |
115 | **Example**
116 | ```js
117 | parser.build(parser.parse('cb2')) // => 'Cb2'
118 | ```
119 | **Example**
120 | ```js
121 | // it accepts (step, alteration, octave) parameters:
122 | parser.build(3) // => 'F'
123 | parser.build(3, -1) // => 'Fb'
124 | parser.build(3, -1, 4) // => 'Fb4'
125 | ```
126 |
127 |
128 | ## midi(note) ⇒ Integer
129 | Get midi of a note
130 |
131 | **Kind**: global function
132 | **Returns**: Integer - the midi number of the note or null if not a valid note
133 | or the note does NOT contains octave
134 |
135 | | Param | Type | Description |
136 | | --- | --- | --- |
137 | | note | String | Integer | the note name or midi number |
138 |
139 | **Example**
140 | ```js
141 | var parser = require('note-parser')
142 | parser.midi('A4') // => 69
143 | parser.midi('A') // => null
144 | ```
145 | **Example**
146 | ```js
147 | // midi numbers are bypassed (even as strings)
148 | parser.midi(60) // => 60
149 | parser.midi('60') // => 60
150 | ```
151 |
152 |
153 | ## freq(note, tuning) ⇒ Float
154 | Get freq of a note in hertzs (in a well tempered 440Hz A4)
155 |
156 | **Kind**: global function
157 | **Returns**: Float - the freq of the number if hertzs or null if not valid note
158 |
159 | | Param | Type | Description |
160 | | --- | --- | --- |
161 | | note | String | the note name or note midi number |
162 | | tuning | String | (Optional) the A4 frequency (440 by default) |
163 |
164 | **Example**
165 | ```js
166 | var parser = require('note-parser')
167 | parser.freq('A4') // => 440
168 | parser.freq('A') // => null
169 | ```
170 | **Example**
171 | ```js
172 | // can change tuning (440 by default)
173 | parser.freq('A4', 444) // => 444
174 | parser.freq('A3', 444) // => 222
175 | ```
176 | **Example**
177 | ```js
178 | // it accepts midi numbers (as numbers and as strings)
179 | parser.freq(69) // => 440
180 | parser.freq('69', 442) // => 442
181 | ```
182 |
--------------------------------------------------------------------------------
/CHANGELOG:
--------------------------------------------------------------------------------
1 | [MASTER]
2 |
3 | [2.0.1]
4 | - Move to ES6 modules with ES5 fallback via rollup
5 | - Add eslint configuration and tests
6 |
7 | [2.0.0]
8 | - API BREAK: remove midiToFreq function (replaced by freq function that now accepts midi numbers too)
9 | - chroma values are always inside 0..11 range
10 | - midi function bypasses midi numbers
11 | - freq accepts midi numbers and an optional tuning parameter
12 |
13 | [1.2.0]
14 | - Add build function
15 |
16 | [1.1.0]
17 | - Add midiToFreq function
18 |
19 | [1.0.0]
20 | - Add better REGEX support
21 | - Add function for each property
22 | - Add chroma, alt
23 |
24 | [0.9.0]
25 | - Add name and remove toString
26 |
27 | [0.8.0]
28 | - Add plus and minus notation (impro-visor style)
29 | - Move to standard js style
30 |
31 | [0.7.0]
32 | - Add midi note
33 | - Add frequency
34 |
35 | [0.6.0]
36 | - Add defaultOctave param
37 | - Add defaultValue param
38 |
39 | [0.5.0]
40 | - Octave is, by default, 4
41 | - Rename pitchClass to pc
42 | - Rename octave to oct
43 | - Rename accidentals acc
44 |
45 | [0.4.0]
46 | - Add parse.toString method
47 |
48 | [0.3.0]
49 | - Rename to note-parser
50 | - Fail fast: parser error now throws exception
51 |
52 | [0.2.0]
53 | - Parse a parsed note return itself
54 |
55 | [0.1.0]
56 | - First version
57 | - Parse notes with accidentals
58 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2015 danigb
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
23 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # note-parser [](https://www.npmjs.com/package/note-parser)
2 |
3 | [](https://travis-ci.org/danigb/note-parser) [](https://codeclimate.com/github/danigb/note-parser)
4 | [](https://github.com/feross/standard)
5 |
6 | Parse note names (in [scientific notation](https://en.wikipedia.org/wiki/Scientific_pitch_notation)) with javascript. Given a string, obtain a hash
7 | with note properties (including midi number and frequency)
8 |
9 | If you need parse interval names take a look to [interval-notation](https://github.com/danigb/interval-notation)
10 |
11 | ## Usage
12 |
13 | Install via npm: `npm i --save note-parser` and require it:
14 |
15 | ```js
16 | var parser = require('note-parser')
17 | parser.parse('c#4') // => { letter: 'C', acc: '#', ... midi: 61, freq: 277.1826309768721 }
18 | ```
19 |
20 | The returned object will contain:
21 |
22 | - `letter`: the uppercase letter of the note
23 | - `acc`: the accidentals of the note (only sharps or flats)
24 | - `pc`: the pitch class (letter + acc)
25 | - `step`: s a numeric representation of the letter. It's an integer from 0 to 6 where 0 = C, 1 = D ... 6 = B
26 | - `alt`: a numeric representation of the accidentals. 0 means no alteration,
27 | positive numbers are for sharps and negative for flats
28 | - `chroma`: a numeric representation of the pitch class. It's like midi for
29 | pitch classes. 0 = C, 1 = C#, 2 = D ... It can have negative values: -1 = Cb.
30 |
31 | If the note name has octave, the returned object will additionally have:
32 |
33 | - `oct`: the octave number (as integer)
34 | - `midi`: the midi number
35 | - `freq`: the frequency (using tuning parameter as base)
36 |
37 | If the parameter `isTonic` is set to true another property is included:
38 |
39 | - `tonicOf`: the rest of the string that follows note name (left and right trimmed)
40 |
41 | #### Midi note number and frequency
42 |
43 | If you are interested only in midi numbers or frequencies, you can use `midi` function:
44 |
45 | ```js
46 | parser.midi('A4') // => 69
47 | parser.midi('blah') // => null
48 | parser.midi(60) // => 60
49 | parser.midi('60') // => 60
50 | ```
51 |
52 | or the `freq` function:
53 |
54 | ```js
55 | parser.freq('A4') // => 440
56 | parser.freq('A3', 444) // => 222
57 | parser.freq(69) // => 440
58 | ```
59 |
60 | ### Build the string back
61 |
62 | With the `build` function you can convert back to string:
63 |
64 | ```js
65 | parser.build(parser.parse('cb2')) // => 'Cb2'
66 | ```
67 |
68 | Alternatively the `build` function accepts `step, alteration, octave` parameters:
69 |
70 | ```js
71 | parser.build(3, -2, 4) // => 'Fbb4'
72 | ```
73 |
74 | ## Tests and documentation
75 |
76 | You can read the [generated API documentation here](https://github.com/danigb/note-parser/blob/master/API.md)
77 |
78 | To run the test clone this repo and:
79 |
80 | ```
81 | npm install
82 | npm test
83 | ```
84 |
85 | ## License
86 |
87 | MIT License
88 |
--------------------------------------------------------------------------------
/dist/note-parser.js:
--------------------------------------------------------------------------------
1 | !function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(t.NoteParser=t.NoteParser||{})}(this,function(t){"use strict";function n(t,n){return Array(n+1).join(t)}function r(t){return"number"==typeof t}function e(t){return"string"==typeof t}function u(t){return void 0!==t}function c(t,n){return Math.pow(2,(t-69)/12)*(n||440)}function o(){return b}function i(t,n,r){if("string"!=typeof t)return null;var e=b.exec(t);if(!e||!n&&e[4])return null;var u={letter:e[1].toUpperCase(),acc:e[2].replace(/x/g,"##")};u.pc=u.letter+u.acc,u.step=(u.letter.charCodeAt(0)+3)%7,u.alt="b"===u.acc[0]?-u.acc.length:u.acc.length;var o=A[u.step]+u.alt;return u.chroma=o<0?12+o:o%12,e[3]&&(u.oct=+e[3],u.midi=o+12*(u.oct+1),u.freq=c(u.midi,r)),n&&(u.tonicOf=e[4]),u}function f(t){return r(t)?t<0?n("b",-t):n("#",t):""}function a(t){return r(t)?""+t:""}function l(t,n,r){return null===t||void 0===t?null:t.step?l(t.step,t.alt,t.oct):t<0||t>6?null:C.charAt(t)+f(n)+a(r)}function p(t){if((r(t)||e(t))&&t>=0&&t<128)return+t;var n=i(t);return n&&u(n.midi)?n.midi:null}function s(t,n){var r=p(t);return null===r?null:c(r,n)}function d(t){return(i(t)||{}).letter}function m(t){return(i(t)||{}).acc}function h(t){return(i(t)||{}).pc}function v(t){return(i(t)||{}).step}function g(t){return(i(t)||{}).alt}function x(t){return(i(t)||{}).chroma}function y(t){return(i(t)||{}).oct}var b=/^([a-gA-G])(#{1,}|b{1,}|x{1,}|)(-?\d*)\s*(.*)\s*$/,A=[0,2,4,5,7,9,11],C="CDEFGAB";t.regex=o,t.parse=i,t.build=l,t.midi=p,t.freq=s,t.letter=d,t.acc=m,t.pc=h,t.step=v,t.alt=g,t.chroma=x,t.oct=y});
2 | //# sourceMappingURL=note-parser.js.map
3 |
--------------------------------------------------------------------------------
/dist/note-parser.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"note-parser.js","sources":["../index.js"],"sourcesContent":["'use strict'\n\n// util\nfunction fillStr (s, num) { return Array(num + 1).join(s) }\nfunction isNum (x) { return typeof x === 'number' }\nfunction isStr (x) { return typeof x === 'string' }\nfunction isDef (x) { return typeof x !== 'undefined' }\nfunction midiToFreq (midi, tuning) {\n return Math.pow(2, (midi - 69) / 12) * (tuning || 440)\n}\n\nvar REGEX = /^([a-gA-G])(#{1,}|b{1,}|x{1,}|)(-?\\d*)\\s*(.*)\\s*$/\n/**\n * A regex for matching note strings in scientific notation.\n *\n * @name regex\n * @function\n * @return {RegExp} the regexp used to parse the note name\n *\n * The note string should have the form `letter[accidentals][octave][element]`\n * where:\n *\n * - letter: (Required) is a letter from A to G either upper or lower case\n * - accidentals: (Optional) can be one or more `b` (flats), `#` (sharps) or `x` (double sharps).\n * They can NOT be mixed.\n * - octave: (Optional) a positive or negative integer\n * - element: (Optional) additionally anything after the duration is considered to\n * be the element name (for example: 'C2 dorian')\n *\n * The executed regex contains (by array index):\n *\n * - 0: the complete string\n * - 1: the note letter\n * - 2: the optional accidentals\n * - 3: the optional octave\n * - 4: the rest of the string (trimmed)\n *\n * @example\n * var parser = require('note-parser')\n * parser.regex.exec('c#4')\n * // => ['c#4', 'c', '#', '4', '']\n * parser.regex.exec('c#4 major')\n * // => ['c#4major', 'c', '#', '4', 'major']\n * parser.regex().exec('CMaj7')\n * // => ['CMaj7', 'C', '', '', 'Maj7']\n */\nexport function regex () { return REGEX }\n\nvar SEMITONES = [0, 2, 4, 5, 7, 9, 11]\n/**\n * Parse a note name in scientific notation an return it's components,\n * and some numeric properties including midi number and frequency.\n *\n * @name parse\n * @function\n * @param {String} note - the note string to be parsed\n * @param {Boolean} isTonic - true the strings it's supposed to contain a note number\n * and some category (for example an scale: 'C# major'). It's false by default,\n * but when true, en extra tonicOf property is returned with the category ('major')\n * @param {Float} tunning - The frequency of A4 note to calculate frequencies.\n * By default it 440.\n * @return {Object} the parsed note name or null if not a valid note\n *\n * The parsed note name object will ALWAYS contains:\n * - letter: the uppercase letter of the note\n * - acc: the accidentals of the note (only sharps or flats)\n * - pc: the pitch class (letter + acc)\n * - step: s a numeric representation of the letter. It's an integer from 0 to 6\n * where 0 = C, 1 = D ... 6 = B\n * - alt: a numeric representation of the accidentals. 0 means no alteration,\n * positive numbers are for sharps and negative for flats\n * - chroma: a numeric representation of the pitch class. It's like midi for\n * pitch classes. 0 = C, 1 = C#, 2 = D ... 11 = B. Can be used to find enharmonics\n * since, for example, chroma of 'Cb' and 'B' are both 11\n *\n * If the note has octave, the parser object will contain:\n * - oct: the octave number (as integer)\n * - midi: the midi number\n * - freq: the frequency (using tuning parameter as base)\n *\n * If the parameter `isTonic` is set to true, the parsed object will contain:\n * - tonicOf: the rest of the string that follows note name (left and right trimmed)\n *\n * @example\n * var parse = require('note-parser').parse\n * parse('Cb4')\n * // => { letter: 'C', acc: 'b', pc: 'Cb', step: 0, alt: -1, chroma: -1,\n * oct: 4, midi: 59, freq: 246.94165062806206 }\n * // if no octave, no midi, no freq\n * parse('fx')\n * // => { letter: 'F', acc: '##', pc: 'F##', step: 3, alt: 2, chroma: 7 })\n */\nexport function parse (str, isTonic, tuning) {\n if (typeof str !== 'string') return null\n var m = REGEX.exec(str)\n if (!m || (!isTonic && m[4])) return null\n\n var p = { letter: m[1].toUpperCase(), acc: m[2].replace(/x/g, '##') }\n p.pc = p.letter + p.acc\n p.step = (p.letter.charCodeAt(0) + 3) % 7\n p.alt = p.acc[0] === 'b' ? -p.acc.length : p.acc.length\n var pos = SEMITONES[p.step] + p.alt\n p.chroma = pos < 0 ? 12 + pos : pos % 12\n if (m[3]) { // has octave\n p.oct = +m[3]\n p.midi = pos + 12 * (p.oct + 1)\n p.freq = midiToFreq(p.midi, tuning)\n }\n if (isTonic) p.tonicOf = m[4]\n return p\n}\n\nvar LETTERS = 'CDEFGAB'\nfunction accStr (n) { return !isNum(n) ? '' : n < 0 ? fillStr('b', -n) : fillStr('#', n) }\nfunction octStr (n) { return !isNum(n) ? '' : '' + n }\n\n/**\n * Create a string from a parsed object or `step, alteration, octave` parameters\n * @param {Object} obj - the parsed data object\n * @return {String} a note string or null if not valid parameters\n * @since 1.2\n * @example\n * parser.build(parser.parse('cb2')) // => 'Cb2'\n *\n * @example\n * // it accepts (step, alteration, octave) parameters:\n * parser.build(3) // => 'F'\n * parser.build(3, -1) // => 'Fb'\n * parser.build(3, -1, 4) // => 'Fb4'\n */\nexport function build (s, a, o) {\n if (s === null || typeof s === 'undefined') return null\n if (s.step) return build(s.step, s.alt, s.oct)\n if (s < 0 || s > 6) return null\n return LETTERS.charAt(s) + accStr(a) + octStr(o)\n}\n\n/**\n * Get midi of a note\n *\n * @name midi\n * @function\n * @param {String|Integer} note - the note name or midi number\n * @return {Integer} the midi number of the note or null if not a valid note\n * or the note does NOT contains octave\n * @example\n * var parser = require('note-parser')\n * parser.midi('A4') // => 69\n * parser.midi('A') // => null\n * @example\n * // midi numbers are bypassed (even as strings)\n * parser.midi(60) // => 60\n * parser.midi('60') // => 60\n */\nexport function midi (note) {\n if ((isNum(note) || isStr(note)) && note >= 0 && note < 128) return +note\n var p = parse(note)\n return p && isDef(p.midi) ? p.midi : null\n}\n\n/**\n * Get freq of a note in hertzs (in a well tempered 440Hz A4)\n *\n * @name freq\n * @function\n * @param {String} note - the note name or note midi number\n * @param {String} tuning - (Optional) the A4 frequency (440 by default)\n * @return {Float} the freq of the number if hertzs or null if not valid note\n * @example\n * var parser = require('note-parser')\n * parser.freq('A4') // => 440\n * parser.freq('A') // => null\n * @example\n * // can change tuning (440 by default)\n * parser.freq('A4', 444) // => 444\n * parser.freq('A3', 444) // => 222\n * @example\n * // it accepts midi numbers (as numbers and as strings)\n * parser.freq(69) // => 440\n * parser.freq('69', 442) // => 442\n */\nexport function freq (note, tuning) {\n var m = midi(note)\n return m === null ? null : midiToFreq(m, tuning)\n}\n\nexport function letter (src) { return (parse(src) || {}).letter }\nexport function acc (src) { return (parse(src) || {}).acc }\nexport function pc (src) { return (parse(src) || {}).pc }\nexport function step (src) { return (parse(src) || {}).step }\nexport function alt (src) { return (parse(src) || {}).alt }\nexport function chroma (src) { return (parse(src) || {}).chroma }\nexport function oct (src) { return (parse(src) || {}).oct }\n"],"names":["fillStr","s","num","Array","join","isNum","x","isStr","isDef","midiToFreq","midi","tuning","Math","pow","regex","REGEX","parse","str","isTonic","m","exec","p","letter","toUpperCase","acc","replace","pc","step","charCodeAt","alt","length","pos","SEMITONES","chroma","oct","freq","tonicOf","accStr","n","octStr","build","a","o","LETTERS","charAt","note","src"],"mappings":"0MAGA,SAASA,GAASC,EAAGC,GAAO,MAAOC,OAAMD,EAAM,GAAGE,KAAKH,GACvD,QAASI,GAAOC,GAAK,MAAoB,gBAANA,GACnC,QAASC,GAAOD,GAAK,MAAoB,gBAANA,GACnC,QAASE,GAAOF,GAAK,WAAoB,KAANA,EACnC,QAASG,GAAYC,EAAMC,GACzB,MAAOC,MAAKC,IAAI,GAAIH,EAAO,IAAM,KAAOC,GAAU,KAsCpD,QAAgBG,KAAW,MAAOC,GA8ClC,QAAgBC,GAAOC,EAAKC,EAASP,GACnC,GAAmB,gBAARM,GAAkB,MAAO,KACpC,IAAIE,GAAIJ,EAAMK,KAAKH,EACnB,KAAKE,IAAOD,GAAWC,EAAE,GAAK,MAAO,KAErC,IAAIE,IAAMC,OAAQH,EAAE,GAAGI,cAAeC,IAAKL,EAAE,GAAGM,QAAQ,KAAM,MAC9DJ,GAAEK,GAAKL,EAAEC,OAASD,EAAEG,IACpBH,EAAEM,MAAQN,EAAEC,OAAOM,WAAW,GAAK,GAAK,EACxCP,EAAEQ,IAAmB,MAAbR,EAAEG,IAAI,IAAcH,EAAEG,IAAIM,OAAST,EAAEG,IAAIM,MACjD,IAAIC,GAAMC,EAAUX,EAAEM,MAAQN,EAAEQ,GAQhC,OAPAR,GAAEY,OAASF,EAAM,EAAI,GAAKA,EAAMA,EAAM,GAClCZ,EAAE,KACJE,EAAEa,KAAOf,EAAE,GACXE,EAAEX,KAAOqB,EAAM,IAAMV,EAAEa,IAAM,GAC7Bb,EAAEc,KAAO1B,EAAWY,EAAEX,KAAMC,IAE1BO,IAASG,EAAEe,QAAUjB,EAAE,IACpBE,EAIT,QAASgB,GAAQC,GAAK,MAAQjC,GAAMiC,GAAUA,EAAI,EAAItC,EAAQ,KAAMsC,GAAKtC,EAAQ,IAAKsC,GAA7C,GACzC,QAASC,GAAQD,GAAK,MAAQjC,GAAMiC,GAAU,GAAKA,EAAV,GAgBzC,QAAgBE,GAAOvC,EAAGwC,EAAGC,GAC3B,MAAU,QAANzC,OAA2B,KAANA,EAA0B,KAC/CA,EAAE0B,KAAaa,EAAMvC,EAAE0B,KAAM1B,EAAE4B,IAAK5B,EAAEiC,KACtCjC,EAAI,GAAKA,EAAI,EAAU,KACpB0C,EAAQC,OAAO3C,GAAKoC,EAAOI,GAAKF,EAAOG,GAoBhD,QAAgBhC,GAAMmC,GACpB,IAAKxC,EAAMwC,IAAStC,EAAMsC,KAAUA,GAAQ,GAAKA,EAAO,IAAK,OAAQA,CACrE,IAAIxB,GAAIL,EAAM6B,EACd,OAAOxB,IAAKb,EAAMa,EAAEX,MAAQW,EAAEX,KAAO,KAwBvC,QAAgByB,GAAMU,EAAMlC,GAC1B,GAAIQ,GAAIT,EAAKmC,EACb,OAAa,QAAN1B,EAAa,KAAOV,EAAWU,EAAGR,GAG3C,QAAgBW,GAAQwB,GAAO,OAAQ9B,EAAM8B,QAAYxB,OACzD,QAAgBE,GAAKsB,GAAO,OAAQ9B,EAAM8B,QAAYtB,IACtD,QAAgBE,GAAIoB,GAAO,OAAQ9B,EAAM8B,QAAYpB,GACrD,QAAgBC,GAAMmB,GAAO,OAAQ9B,EAAM8B,QAAYnB,KACvD,QAAgBE,GAAKiB,GAAO,OAAQ9B,EAAM8B,QAAYjB,IACtD,QAAgBI,GAAQa,GAAO,OAAQ9B,EAAM8B,QAAYb,OACzD,QAAgBC,GAAKY,GAAO,OAAQ9B,EAAM8B,QAAYZ,IArLtD,GAAInB,GAAQ,oDAqCRiB,GAAa,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAgE/BW,EAAU"}
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | 'use strict'
2 |
3 | // util
4 | function fillStr (s, num) { return Array(num + 1).join(s) }
5 | function isNum (x) { return typeof x === 'number' }
6 | function isStr (x) { return typeof x === 'string' }
7 | function isDef (x) { return typeof x !== 'undefined' }
8 | function midiToFreq (midi, tuning) {
9 | return Math.pow(2, (midi - 69) / 12) * (tuning || 440)
10 | }
11 |
12 | var REGEX = /^([a-gA-G])(#{1,}|b{1,}|x{1,}|)(-?\d*)\s*(.*)\s*$/
13 | /**
14 | * A regex for matching note strings in scientific notation.
15 | *
16 | * @name regex
17 | * @function
18 | * @return {RegExp} the regexp used to parse the note name
19 | *
20 | * The note string should have the form `letter[accidentals][octave][element]`
21 | * where:
22 | *
23 | * - letter: (Required) is a letter from A to G either upper or lower case
24 | * - accidentals: (Optional) can be one or more `b` (flats), `#` (sharps) or `x` (double sharps).
25 | * They can NOT be mixed.
26 | * - octave: (Optional) a positive or negative integer
27 | * - element: (Optional) additionally anything after the duration is considered to
28 | * be the element name (for example: 'C2 dorian')
29 | *
30 | * The executed regex contains (by array index):
31 | *
32 | * - 0: the complete string
33 | * - 1: the note letter
34 | * - 2: the optional accidentals
35 | * - 3: the optional octave
36 | * - 4: the rest of the string (trimmed)
37 | *
38 | * @example
39 | * var parser = require('note-parser')
40 | * parser.regex.exec('c#4')
41 | * // => ['c#4', 'c', '#', '4', '']
42 | * parser.regex.exec('c#4 major')
43 | * // => ['c#4major', 'c', '#', '4', 'major']
44 | * parser.regex().exec('CMaj7')
45 | * // => ['CMaj7', 'C', '', '', 'Maj7']
46 | */
47 | export function regex () { return REGEX }
48 |
49 | var SEMITONES = [0, 2, 4, 5, 7, 9, 11]
50 | /**
51 | * Parse a note name in scientific notation an return it's components,
52 | * and some numeric properties including midi number and frequency.
53 | *
54 | * @name parse
55 | * @function
56 | * @param {String} note - the note string to be parsed
57 | * @param {Boolean} isTonic - true the strings it's supposed to contain a note number
58 | * and some category (for example an scale: 'C# major'). It's false by default,
59 | * but when true, en extra tonicOf property is returned with the category ('major')
60 | * @param {Float} tunning - The frequency of A4 note to calculate frequencies.
61 | * By default it 440.
62 | * @return {Object} the parsed note name or null if not a valid note
63 | *
64 | * The parsed note name object will ALWAYS contains:
65 | * - letter: the uppercase letter of the note
66 | * - acc: the accidentals of the note (only sharps or flats)
67 | * - pc: the pitch class (letter + acc)
68 | * - step: s a numeric representation of the letter. It's an integer from 0 to 6
69 | * where 0 = C, 1 = D ... 6 = B
70 | * - alt: a numeric representation of the accidentals. 0 means no alteration,
71 | * positive numbers are for sharps and negative for flats
72 | * - chroma: a numeric representation of the pitch class. It's like midi for
73 | * pitch classes. 0 = C, 1 = C#, 2 = D ... 11 = B. Can be used to find enharmonics
74 | * since, for example, chroma of 'Cb' and 'B' are both 11
75 | *
76 | * If the note has octave, the parser object will contain:
77 | * - oct: the octave number (as integer)
78 | * - midi: the midi number
79 | * - freq: the frequency (using tuning parameter as base)
80 | *
81 | * If the parameter `isTonic` is set to true, the parsed object will contain:
82 | * - tonicOf: the rest of the string that follows note name (left and right trimmed)
83 | *
84 | * @example
85 | * var parse = require('note-parser').parse
86 | * parse('Cb4')
87 | * // => { letter: 'C', acc: 'b', pc: 'Cb', step: 0, alt: -1, chroma: -1,
88 | * oct: 4, midi: 59, freq: 246.94165062806206 }
89 | * // if no octave, no midi, no freq
90 | * parse('fx')
91 | * // => { letter: 'F', acc: '##', pc: 'F##', step: 3, alt: 2, chroma: 7 })
92 | */
93 | export function parse (str, isTonic, tuning) {
94 | if (typeof str !== 'string') return null
95 | var m = REGEX.exec(str)
96 | if (!m || (!isTonic && m[4])) return null
97 |
98 | var p = { letter: m[1].toUpperCase(), acc: m[2].replace(/x/g, '##') }
99 | p.pc = p.letter + p.acc
100 | p.step = (p.letter.charCodeAt(0) + 3) % 7
101 | p.alt = p.acc[0] === 'b' ? -p.acc.length : p.acc.length
102 | var pos = SEMITONES[p.step] + p.alt
103 | p.chroma = pos < 0 ? 12 + pos : pos % 12
104 | if (m[3]) { // has octave
105 | p.oct = +m[3]
106 | p.midi = pos + 12 * (p.oct + 1)
107 | p.freq = midiToFreq(p.midi, tuning)
108 | }
109 | if (isTonic) p.tonicOf = m[4]
110 | return p
111 | }
112 |
113 | var LETTERS = 'CDEFGAB'
114 | function accStr (n) { return !isNum(n) ? '' : n < 0 ? fillStr('b', -n) : fillStr('#', n) }
115 | function octStr (n) { return !isNum(n) ? '' : '' + n }
116 |
117 | /**
118 | * Create a string from a parsed object or `step, alteration, octave` parameters
119 | * @param {Object} obj - the parsed data object
120 | * @return {String} a note string or null if not valid parameters
121 | * @since 1.2
122 | * @example
123 | * parser.build(parser.parse('cb2')) // => 'Cb2'
124 | *
125 | * @example
126 | * // it accepts (step, alteration, octave) parameters:
127 | * parser.build(3) // => 'F'
128 | * parser.build(3, -1) // => 'Fb'
129 | * parser.build(3, -1, 4) // => 'Fb4'
130 | */
131 | export function build (s, a, o) {
132 | if (s === null || typeof s === 'undefined') return null
133 | if (s.step) return build(s.step, s.alt, s.oct)
134 | if (s < 0 || s > 6) return null
135 | return LETTERS.charAt(s) + accStr(a) + octStr(o)
136 | }
137 |
138 | /**
139 | * Get midi of a note
140 | *
141 | * @name midi
142 | * @function
143 | * @param {String|Integer} note - the note name or midi number
144 | * @return {Integer} the midi number of the note or null if not a valid note
145 | * or the note does NOT contains octave
146 | * @example
147 | * var parser = require('note-parser')
148 | * parser.midi('A4') // => 69
149 | * parser.midi('A') // => null
150 | * @example
151 | * // midi numbers are bypassed (even as strings)
152 | * parser.midi(60) // => 60
153 | * parser.midi('60') // => 60
154 | */
155 | export function midi (note) {
156 | if ((isNum(note) || isStr(note)) && note >= 0 && note < 128) return +note
157 | var p = parse(note)
158 | return p && isDef(p.midi) ? p.midi : null
159 | }
160 |
161 | /**
162 | * Get freq of a note in hertzs (in a well tempered 440Hz A4)
163 | *
164 | * @name freq
165 | * @function
166 | * @param {String} note - the note name or note midi number
167 | * @param {String} tuning - (Optional) the A4 frequency (440 by default)
168 | * @return {Float} the freq of the number if hertzs or null if not valid note
169 | * @example
170 | * var parser = require('note-parser')
171 | * parser.freq('A4') // => 440
172 | * parser.freq('A') // => null
173 | * @example
174 | * // can change tuning (440 by default)
175 | * parser.freq('A4', 444) // => 444
176 | * parser.freq('A3', 444) // => 222
177 | * @example
178 | * // it accepts midi numbers (as numbers and as strings)
179 | * parser.freq(69) // => 440
180 | * parser.freq('69', 442) // => 442
181 | */
182 | export function freq (note, tuning) {
183 | var m = midi(note)
184 | return m === null ? null : midiToFreq(m, tuning)
185 | }
186 |
187 | export function letter (src) { return (parse(src) || {}).letter }
188 | export function acc (src) { return (parse(src) || {}).acc }
189 | export function pc (src) { return (parse(src) || {}).pc }
190 | export function step (src) { return (parse(src) || {}).step }
191 | export function alt (src) { return (parse(src) || {}).alt }
192 | export function chroma (src) { return (parse(src) || {}).chroma }
193 | export function oct (src) { return (parse(src) || {}).oct }
194 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "note-parser",
3 | "version": "2.0.1",
4 | "description": "Parse music notes in scientific notation",
5 | "main": "dist/note-parser.js",
6 | "jsnext:main": "index.js",
7 | "module": "index.js",
8 | "scripts": {
9 | "pretest": "npm run build",
10 | "test": "eslint index.js && mocha",
11 | "api": "jsdoc2md index.js > API.md",
12 | "build": "rollup -cm -n NoteParser -f umd -i index.js -o dist/note-parser.js",
13 | "prepublish": "npm run build",
14 | "release": "npm run build && npm test && git commit -am $npm_package_version && git tag $npm_package_version && git push && git push --tags && npm publish"
15 | },
16 | "repository": {
17 | "type": "git",
18 | "url": "git+https://github.com/danigb/note-parser.git"
19 | },
20 | "keywords": [
21 | "note",
22 | "parse",
23 | "parser",
24 | "midi",
25 | "scientific",
26 | "notation",
27 | "frequency"
28 | ],
29 | "author": "danigb