Sakurai/pdf.js
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
8943bcd3c3
pdf.js/src/core/cff_parser.js

1934 lines
60 KiB
JavaScript
Raw Normal View History

Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
/* Copyright 2016 Mozilla Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Convert the files in the `/src/core` folder to ES6 modules Please note that the `glyphlist.js` and `unicode.js` files are converted to CommonJS modules instead, since Babel cannot handle files that large and they are thus excluded from transpilation.
2017-04-02 23:14:30 +09:00
import {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
bytesToString,
FormatError,
info,
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
shadow,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
stringToBytes,
Util,
warn,
Ensure that all `import` and `require` statements, in the entire code-base, have a `.js` file extension In order to eventually get rid of SystemJS and start using native `import`s instead, we'll need to provide "complete" file identifiers since otherwise there'll be MIME type errors when attempting to use `import`.
2020-01-02 20:00:16 +09:00
} from "../shared/util.js";
Convert the files in the `/src/core` folder to ES6 modules Please note that the `glyphlist.js` and `unicode.js` files are converted to CommonJS modules instead, since Babel cannot handle files that large and they are thus excluded from transpilation.
2017-04-02 23:14:30 +09:00
import {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
ExpertCharset,
ExpertSubsetCharset,
ISOAdobeCharset,
Ensure that all `import` and `require` statements, in the entire code-base, have a `.js` file extension In order to eventually get rid of SystemJS and start using native `import`s instead, we'll need to provide "complete" file identifiers since otherwise there'll be MIME type errors when attempting to use `import`.
2020-01-02 20:00:16 +09:00
} from "./charsets.js";
import { ExpertEncoding, StandardEncoding } from "./encodings.js";
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// Maximum subroutine call depth of type 2 chartrings. Matches OTS.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const MAX_SUBR_NESTING = 10;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
/**
* The CFF class takes a Type1 file and wrap it into a
* 'Compact Font Format' which itself embed Type2 charstrings.
*/
Add `// prettier-ignore` comments to prevent re-formatting of certain data structures There's a fair number of (primarily) `Array`s/`TypedArray`s whose formatting we don't want disturb, since in many cases that would lead to the code becoming much more difficult to read and/or break existing inline comments. *Please note:* It may be a good idea to look through these cases individually, and possibly re-write some of the them (especially the `String` ones) to reduce the need for all of these ignore commands.
2019-12-25 23:54:34 +09:00
// prettier-ignore
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CFFStandardStrings = [
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
".notdef", "space", "exclam", "quotedbl", "numbersign", "dollar", "percent",
"ampersand", "quoteright", "parenleft", "parenright", "asterisk", "plus",
"comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four",
"five", "six", "seven", "eight", "nine", "colon", "semicolon", "less",
"equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H",
"I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W",
"X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum",
"underscore", "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
"k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y",
"z", "braceleft", "bar", "braceright", "asciitilde", "exclamdown", "cent",
"sterling", "fraction", "yen", "florin", "section", "currency",
"quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft",
"guilsinglright", "fi", "fl", "endash", "dagger", "daggerdbl",
"periodcentered", "paragraph", "bullet", "quotesinglbase", "quotedblbase",
"quotedblright", "guillemotright", "ellipsis", "perthousand", "questiondown",
"grave", "acute", "circumflex", "tilde", "macron", "breve", "dotaccent",
"dieresis", "ring", "cedilla", "hungarumlaut", "ogonek", "caron", "emdash",
"AE", "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine", "ae",
"dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior",
"logicalnot", "mu", "trademark", "Eth", "onehalf", "plusminus", "Thorn",
"onequarter", "divide", "brokenbar", "degree", "thorn", "threequarters",
"twosuperior", "registered", "minus", "eth", "multiply", "threesuperior",
"copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave", "Aring",
"Atilde", "Ccedilla", "Eacute", "Ecircumflex", "Edieresis", "Egrave",
"Iacute", "Icircumflex", "Idieresis", "Igrave", "Ntilde", "Oacute",
"Ocircumflex", "Odieresis", "Ograve", "Otilde", "Scaron", "Uacute",
"Ucircumflex", "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron",
"aacute", "acircumflex", "adieresis", "agrave", "aring", "atilde",
"ccedilla", "eacute", "ecircumflex", "edieresis", "egrave", "iacute",
"icircumflex", "idieresis", "igrave", "ntilde", "oacute", "ocircumflex",
"odieresis", "ograve", "otilde", "scaron", "uacute", "ucircumflex",
"udieresis", "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall",
"Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall",
"Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader",
"onedotenleader", "zerooldstyle", "oneoldstyle", "twooldstyle",
"threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle",
"sevenoldstyle", "eightoldstyle", "nineoldstyle", "commasuperior",
"threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
"bsuperior", "centsuperior", "dsuperior", "esuperior", "isuperior",
"lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior",
"tsuperior", "ff", "ffi", "ffl", "parenleftinferior", "parenrightinferior",
"Circumflexsmall", "hyphensuperior", "Gravesmall", "Asmall", "Bsmall",
"Csmall", "Dsmall", "Esmall", "Fsmall", "Gsmall", "Hsmall", "Ismall",
"Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall",
"Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall", "Wsmall",
"Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah",
"Tildesmall", "exclamdownsmall", "centoldstyle", "Lslashsmall",
"Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall",
"Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior",
"Ogoneksmall", "Ringsmall", "Cedillasmall", "questiondownsmall", "oneeighth",
"threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds",
"zerosuperior", "foursuperior", "fivesuperior", "sixsuperior",
"sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior",
"oneinferior", "twoinferior", "threeinferior", "fourinferior",
"fiveinferior", "sixinferior", "seveninferior", "eightinferior",
"nineinferior", "centinferior", "dollarinferior", "periodinferior",
"commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall",
"Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall",
"Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall",
"Igravesmall", "Iacutesmall", "Icircumflexsmall", "Idieresissmall",
"Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall",
"Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall",
"Uacutesmall", "Ucircumflexsmall", "Udieresissmall", "Yacutesmall",
"Thornsmall", "Ydieresissmall", "001.000", "001.001", "001.002", "001.003",
"Black", "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold"
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
];
Add unique glyph names for CFF fonts. Printing on MacOS was broken with the previous approach of just mapping all the glyphs to notdef.
2019-02-27 08:57:46 +09:00
const NUM_STANDARD_CFF_STRINGS = 391;
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CFFParser = (function CFFParserClosure() {
const CharstringValidationData = [
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "hstem", min: 2, stackClearing: true, stem: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "vstem", min: 2, stackClearing: true, stem: true },
{ id: "vmoveto", min: 1, stackClearing: true },
{ id: "rlineto", min: 2, resetStack: true },
{ id: "hlineto", min: 1, resetStack: true },
{ id: "vlineto", min: 1, resetStack: true },
{ id: "rrcurveto", min: 6, resetStack: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "callsubr", min: 1, undefStack: true },
{ id: "return", min: 0, undefStack: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null, // 12
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "endchar", min: 0, stackClearing: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
null,
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "hstemhm", min: 2, stackClearing: true, stem: true },
{ id: "hintmask", min: 0, stackClearing: true },
{ id: "cntrmask", min: 0, stackClearing: true },
{ id: "rmoveto", min: 2, stackClearing: true },
{ id: "hmoveto", min: 1, stackClearing: true },
{ id: "vstemhm", min: 2, stackClearing: true, stem: true },
{ id: "rcurveline", min: 8, resetStack: true },
{ id: "rlinecurve", min: 8, resetStack: true },
{ id: "vvcurveto", min: 4, resetStack: true },
{ id: "hhcurveto", min: 4, resetStack: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null, // shortint
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "callgsubr", min: 1, undefStack: true },
{ id: "vhcurveto", min: 4, resetStack: true },
{ id: "hvcurveto", min: 4, resetStack: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
];
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CharstringValidationData12 = [
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
null,
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "and", min: 2, stackDelta: -1 },
{ id: "or", min: 2, stackDelta: -1 },
{ id: "not", min: 1, stackDelta: 0 },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
null,
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "abs", min: 1, stackDelta: 0 },
{
id: "add",
min: 2,
stackDelta: -1,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stackFn: function stack_div(stack, index) {
stack[index - 2] = stack[index - 2] + stack[index - 1];
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
},
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{
id: "sub",
min: 2,
stackDelta: -1,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stackFn: function stack_div(stack, index) {
stack[index - 2] = stack[index - 2] - stack[index - 1];
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
},
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{
id: "div",
min: 2,
stackDelta: -1,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stackFn: function stack_div(stack, index) {
stack[index - 2] = stack[index - 2] / stack[index - 1];
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
},
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{
id: "neg",
min: 1,
stackDelta: 0,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stackFn: function stack_div(stack, index) {
stack[index - 1] = -stack[index - 1];
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
},
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "eq", min: 2, stackDelta: -1 },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "drop", min: 1, stackDelta: -1 },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "put", min: 2, stackDelta: -2 },
{ id: "get", min: 1, stackDelta: 0 },
{ id: "ifelse", min: 4, stackDelta: -3 },
{ id: "random", min: 0, stackDelta: 1 },
{
id: "mul",
min: 2,
stackDelta: -1,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stackFn: function stack_div(stack, index) {
stack[index - 2] = stack[index - 2] * stack[index - 1];
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
},
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "sqrt", min: 1, stackDelta: 0 },
{ id: "dup", min: 1, stackDelta: 1 },
{ id: "exch", min: 2, stackDelta: 0 },
{ id: "index", min: 2, stackDelta: 0 },
{ id: "roll", min: 3, stackDelta: -2 },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
null,
null,
null,
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
{ id: "hflex", min: 7, resetStack: true },
{ id: "flex", min: 13, resetStack: true },
{ id: "hflex1", min: 9, resetStack: true },
{ id: "flex1", min: 11, resetStack: true },
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
];
Whitelist closure related cases to address the remaining `no-shadow` linting errors Given the way that "classes" were previously implemented in PDF.js, using regular functions and closures, there's a fair number of false positives when the `no-shadow` ESLint rule was enabled. Note that while *some* of these `eslint-disable` statements can be removed if/when the relevant code is converted to proper `class`es, we'll probably never be able to get rid of all of them given our naming/coding conventions (however I don't really see this being a problem).
2020-03-25 18:15:50 +09:00
// eslint-disable-next-line no-shadow
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFParser {
constructor(file, properties, seacAnalysisEnabled) {
this.bytes = file.getBytes();
this.properties = properties;
this.seacAnalysisEnabled = !!seacAnalysisEnabled;
}
parse() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const properties = this.properties;
const cff = new CFF();
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.cff = cff;
// The first five sections must be in order, all the others are reached
// via offsets contained in one of the below.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const header = this.parseHeader();
const nameIndex = this.parseIndex(header.endPos);
const topDictIndex = this.parseIndex(nameIndex.endPos);
const stringIndex = this.parseIndex(topDictIndex.endPos);
const globalSubrIndex = this.parseIndex(stringIndex.endPos);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const topDictParsed = this.parseDict(topDictIndex.obj.get(0));
const topDict = this.createDict(CFFTopDict, topDictParsed, cff.strings);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
cff.header = header.obj;
cff.names = this.parseNameIndex(nameIndex.obj);
cff.strings = this.parseStringIndex(stringIndex.obj);
cff.topDict = topDict;
cff.globalSubrIndex = globalSubrIndex.obj;
this.parsePrivateDict(cff.topDict);
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
cff.isCIDFont = topDict.hasName("ROS");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const charStringOffset = topDict.getByName("CharStrings");
const charStringIndex = this.parseIndex(charStringOffset).obj;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fontMatrix = topDict.getByName("FontMatrix");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (fontMatrix) {
properties.fontMatrix = fontMatrix;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fontBBox = topDict.getByName("FontBBox");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (fontBBox) {
// adjusting ascent/descent
Font ascent descent calculation fix
2017-02-11 15:25:05 +09:00
properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
properties.descent = Math.min(fontBBox[1], fontBBox[3]);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
properties.ascentScaled = true;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let charset, encoding;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (cff.isCIDFont) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fdArrayIndex = this.parseIndex(topDict.getByName("FDArray")).obj;
for (let i = 0, ii = fdArrayIndex.count; i < ii; ++i) {
const dictRaw = fdArrayIndex.get(i);
const fontDict = this.createDict(
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
CFFTopDict,
this.parseDict(dictRaw),
cff.strings
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.parsePrivateDict(fontDict);
cff.fdArray.push(fontDict);
}
// cid fonts don't have an encoding
encoding = null;
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
charset = this.parseCharsets(
topDict.getByName("charset"),
charStringIndex.count,
cff.strings,
true
);
cff.fdSelect = this.parseFDSelect(
topDict.getByName("FDSelect"),
charStringIndex.count
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
charset = this.parseCharsets(
topDict.getByName("charset"),
charStringIndex.count,
cff.strings,
false
);
encoding = this.parseEncoding(
topDict.getByName("Encoding"),
properties,
cff.strings,
charset.charset
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
cff.charset = charset;
cff.encoding = encoding;
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const charStringsAndSeacs = this.parseCharStrings({
Fixes CFF data glyph widths
2017-07-08 05:12:52 +09:00
charStrings: charStringIndex,
localSubrIndex: topDict.privateDict.subrsIndex,
globalSubrIndex: globalSubrIndex.obj,
fdSelect: cff.fdSelect,
fdArray: cff.fdArray,
privateDict: topDict.privateDict,
});
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
cff.charStrings = charStringsAndSeacs.charStrings;
cff.seacs = charStringsAndSeacs.seacs;
cff.widths = charStringsAndSeacs.widths;
return cff;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseHeader() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let bytes = this.bytes;
const bytesLength = bytes.length;
let offset = 0;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// Prevent an infinite loop, by checking that the offset is within the
// bounds of the bytes array. Necessary in empty, or invalid, font files.
while (offset < bytesLength && bytes[offset] !== 1) {
++offset;
}
if (offset >= bytesLength) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
throw new FormatError("Invalid CFF header");
Removes error()
2017-06-29 05:51:31 +09:00
}
if (offset !== 0) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
info("cff data is shifted");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
bytes = bytes.subarray(offset);
this.bytes = bytes;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const major = bytes[0];
const minor = bytes[1];
const hdrSize = bytes[2];
const offSize = bytes[3];
const header = new CFFHeader(major, minor, hdrSize, offSize);
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return { obj: header, endPos: hdrSize };
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseDict(dict) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let pos = 0;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
function parseOperand() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let value = dict[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (value === 30) {
Fixes some static analysis warnings and recommendations * Useless conditional * Superfluous trailing arguments * Useless assignment to local variable * Misspelled identifier * JSDoc tag for non-existent parameter
2016-05-03 07:34:58 +09:00
return parseFloatOperand();
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else if (value === 28) {
value = dict[pos++];
value = ((value << 24) | (dict[pos++] << 16)) >> 16;
return value;
} else if (value === 29) {
value = dict[pos++];
value = (value << 8) | dict[pos++];
value = (value << 8) | dict[pos++];
value = (value << 8) | dict[pos++];
return value;
} else if (value >= 32 && value <= 246) {
return value - 139;
} else if (value >= 247 && value <= 250) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return (value - 247) * 256 + dict[pos++] + 108;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else if (value >= 251 && value <= 254) {
return -((value - 251) * 256) - dict[pos++] - 108;
}
Enable the `no-else-return` ESLint rule Using `else` after `return` is not necessary, and can often lead to unnecessarily cluttered code. By using the `no-else-return` rule in ESLint we can avoid this pattern, see http://eslint.org/docs/rules/no-else-return.
2016-12-16 21:05:33 +09:00
warn('CFFParser_parseDict: "' + value + '" is a reserved command.');
return NaN;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
function parseFloatOperand() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let str = "";
const eof = 15;
Add `// prettier-ignore` comments to prevent re-formatting of certain data structures There's a fair number of (primarily) `Array`s/`TypedArray`s whose formatting we don't want disturb, since in many cases that would lead to the code becoming much more difficult to read and/or break existing inline comments. *Please note:* It may be a good idea to look through these cases individually, and possibly re-write some of the them (especially the `String` ones) to reduce the need for all of these ignore commands.
2019-12-25 23:54:34 +09:00
// prettier-ignore
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
const lookup = ["0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", ".", "E", "E-", null, "-"];
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const length = dict.length;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
while (pos < length) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const b = dict[pos++];
const b1 = b >> 4;
const b2 = b & 15;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (b1 === eof) {
break;
}
str += lookup[b1];
if (b2 === eof) {
break;
}
str += lookup[b2];
}
return parseFloat(str);
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let operands = [];
const entries = [];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
pos = 0;
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const end = dict.length;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
while (pos < end) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let b = dict[pos];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (b <= 21) {
if (b === 12) {
b = (b << 8) | dict[++pos];
}
entries.push([b, operands]);
operands = [];
++pos;
} else {
operands.push(parseOperand());
}
}
return entries;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseIndex(pos) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const cffIndex = new CFFIndex();
const bytes = this.bytes;
const count = (bytes[pos++] << 8) | bytes[pos++];
const offsets = [];
let end = pos;
let i, ii;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (count !== 0) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const offsetSize = bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// add 1 for offset to determine size of last object
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const startPos = pos + (count + 1) * offsetSize - 1;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 0, ii = count + 1; i < ii; ++i) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let offset = 0;
for (let j = 0; j < offsetSize; ++j) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
offset <<= 8;
offset += bytes[pos++];
}
offsets.push(startPos + offset);
}
end = offsets[count];
}
for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const offsetStart = offsets[i];
const offsetEnd = offsets[i + 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return { obj: cffIndex, endPos: end };
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseNameIndex(index) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const names = [];
for (let i = 0, ii = index.count; i < ii; ++i) {
const name = index.get(i);
Sanitize name index in compile phase of CFF. Fixes #8960
2017-10-19 10:33:35 +09:00
names.push(bytesToString(name));
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
return names;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseStringIndex(index) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const strings = new CFFStrings();
for (let i = 0, ii = index.count; i < ii; ++i) {
const data = index.get(i);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
strings.add(bytesToString(data));
}
return strings;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
createDict(Type, dict, strings) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const cffDict = new Type(strings);
for (let i = 0, ii = dict.length; i < ii; ++i) {
const pair = dict[i];
const key = pair[0];
const value = pair[1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
cffDict.setByKey(key, value);
}
return cffDict;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseCharString(state, data, localSubrIndex, globalSubrIndex) {
Handle cff fonts with erroneous stackSize
2017-03-07 09:17:27 +09:00
if (!data || state.callDepth > MAX_SUBR_NESTING) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return false;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let stackSize = state.stackSize;
const stack = state.stack;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const length = data.length;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let j = 0; j < length; ) {
const value = data[j++];
let validationCommand = null;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (value === 12) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const q = data[j++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (q === 0) {
// The CFF specification state that the 'dotsection' command
// (12, 0) is deprecated and treated as a no-op, but all Type2
// charstrings processors should support them. Unfortunately
// the font sanitizer don't. As a workaround the sequence (12, 0)
// is replaced by a useless (0, hmoveto).
data[j - 2] = 139;
data[j - 1] = 22;
stackSize = 0;
} else {
validationCommand = CharstringValidationData12[q];
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
} else if (value === 28) {
// number (16 bit)
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stack[stackSize] = ((data[j] << 24) | (data[j + 1] << 16)) >> 16;
j += 2;
stackSize++;
} else if (value === 14) {
if (stackSize >= 4) {
stackSize -= 4;
if (this.seacAnalysisEnabled) {
state.seac = stack.slice(stackSize, stackSize + 4);
return false;
}
}
validationCommand = CharstringValidationData[value];
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
} else if (value >= 32 && value <= 246) {
// number
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
stack[stackSize] = value - 139;
stackSize++;
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
} else if (value >= 247 && value <= 254) {
// number (+1 bytes)
stack[stackSize] =
value < 251
? ((value - 247) << 8) + data[j] + 108
: -((value - 251) << 8) - data[j] - 108;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
j++;
stackSize++;
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
} else if (value === 255) {
// number (32 bit)
stack[stackSize] =
((data[j] << 24) |
(data[j + 1] << 16) |
(data[j + 2] << 8) |
data[j + 3]) /
65536;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
j += 4;
stackSize++;
} else if (value === 19 || value === 20) {
state.hints += stackSize >> 1;
// skipping right amount of hints flag data
j += (state.hints + 7) >> 3;
stackSize %= 2;
validationCommand = CharstringValidationData[value];
} else if (value === 10 || value === 29) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let subrsIndex;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (value === 10) {
subrsIndex = localSubrIndex;
} else {
subrsIndex = globalSubrIndex;
}
if (!subrsIndex) {
validationCommand = CharstringValidationData[value];
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("Missing subrsIndex for " + validationCommand.id);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return false;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let bias = 32768;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (subrsIndex.count < 1240) {
bias = 107;
} else if (subrsIndex.count < 33900) {
bias = 1131;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const subrNumber = stack[--stackSize] + bias;
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if (
subrNumber < 0 ||
subrNumber >= subrsIndex.count ||
isNaN(subrNumber)
) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
validationCommand = CharstringValidationData[value];
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("Out of bounds subrIndex for " + validationCommand.id);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return false;
}
state.stackSize = stackSize;
state.callDepth++;
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const valid = this.parseCharString(
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
state,
subrsIndex.get(subrNumber),
localSubrIndex,
globalSubrIndex
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (!valid) {
return false;
}
state.callDepth--;
stackSize = state.stackSize;
continue;
} else if (value === 11) {
state.stackSize = stackSize;
return true;
} else {
validationCommand = CharstringValidationData[value];
}
if (validationCommand) {
if (validationCommand.stem) {
state.hints += stackSize >> 1;
Repair CFF fonts if stem hints are in wrong order
2018-11-21 01:50:37 +09:00
if (value === 3 || value === 23) {
// vstem or vstemhm.
state.hasVStems = true;
} else if (state.hasVStems && (value === 1 || value === 18)) {
// Some browsers don't draw glyphs that specify vstems before
// hstems. As a workaround, replace hstem (1) and hstemhm (18)
// with a pointless vstem (3) or vstemhm (23).
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("CFF stem hints are in wrong order");
data[j - 1] = value === 1 ? 3 : 23;
Repair CFF fonts if stem hints are in wrong order
2018-11-21 01:50:37 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if ("min" in validationCommand) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (!state.undefStack && stackSize < validationCommand.min) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn(
"Not enough parameters for " +
validationCommand.id +
"; actual: " +
stackSize +
", expected: " +
validationCommand.min
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return false;
}
}
if (state.firstStackClearing && validationCommand.stackClearing) {
state.firstStackClearing = false;
// the optional character width can be found before the first
// stack-clearing command arguments
stackSize -= validationCommand.min;
if (stackSize >= 2 && validationCommand.stem) {
// there are even amount of arguments for stem commands
stackSize %= 2;
} else if (stackSize > 1) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("Found too many parameters for stack-clearing command");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
if (stackSize > 0 && stack[stackSize - 1] >= 0) {
state.width = stack[stackSize - 1];
}
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if ("stackDelta" in validationCommand) {
if ("stackFn" in validationCommand) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
validationCommand.stackFn(stack, stackSize);
}
stackSize += validationCommand.stackDelta;
} else if (validationCommand.stackClearing) {
stackSize = 0;
} else if (validationCommand.resetStack) {
stackSize = 0;
state.undefStack = false;
} else if (validationCommand.undefStack) {
stackSize = 0;
state.undefStack = true;
state.firstStackClearing = false;
}
}
}
state.stackSize = stackSize;
return true;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
parseCharStrings({
charStrings,
localSubrIndex,
globalSubrIndex,
fdSelect,
fdArray,
privateDict,
}) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const seacs = [];
const widths = [];
const count = charStrings.count;
for (let i = 0; i < count; i++) {
const charstring = charStrings.get(i);
const state = {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
callDepth: 0,
stackSize: 0,
stack: [],
undefStack: true,
hints: 0,
firstStackClearing: true,
seac: null,
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
width: null,
Repair CFF fonts if stem hints are in wrong order
2018-11-21 01:50:37 +09:00
hasVStems: false,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
};
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let valid = true;
let localSubrToUse = null;
let privateDictToUse = privateDict;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (fdSelect && fdArray.length) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fdIndex = fdSelect.getFDIndex(i);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (fdIndex === -1) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("Glyph index is not in fd select.");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
valid = false;
}
if (fdIndex >= fdArray.length) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn("Invalid fd index for glyph index.");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
valid = false;
}
if (valid) {
Fixes CFF data glyph widths
2017-07-08 05:12:52 +09:00
privateDictToUse = fdArray[fdIndex].privateDict;
localSubrToUse = privateDictToUse.subrsIndex;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
} else if (localSubrIndex) {
localSubrToUse = localSubrIndex;
}
if (valid) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
valid = this.parseCharString(
state,
charstring,
localSubrToUse,
globalSubrIndex
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
if (state.width !== null) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
const nominalWidth = privateDictToUse.getByName("nominalWidthX");
Fixes CFF data glyph widths
2017-07-08 05:12:52 +09:00
widths[i] = nominalWidth + state.width;
} else {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
const defaultWidth = privateDictToUse.getByName("defaultWidthX");
Fixes CFF data glyph widths
2017-07-08 05:12:52 +09:00
widths[i] = defaultWidth;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
if (state.seac !== null) {
seacs[i] = state.seac;
}
if (!valid) {
// resetting invalid charstring to single 'endchar'
charStrings.set(i, new Uint8Array([14]));
}
}
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return { charStrings, seacs, widths };
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
emptyPrivateDictionary(parentDict) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const privateDict = this.createDict(
CFFPrivateDict,
[],
parentDict.strings
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
parentDict.setByKey(18, [0, 0]);
parentDict.privateDict = privateDict;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parsePrivateDict(parentDict) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// no private dict, do nothing
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if (!parentDict.hasName("Private")) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.emptyPrivateDictionary(parentDict);
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const privateOffset = parentDict.getByName("Private");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// make sure the params are formatted correctly
Replace the `isArray` helper function with the native `Array.isArray` function *Follow-up to PR 8813.*
2017-09-02 03:27:13 +09:00
if (!Array.isArray(privateOffset) || privateOffset.length !== 2) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
parentDict.removeByName("Private");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const size = privateOffset[0];
const offset = privateOffset[1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// remove empty dicts or ones that refer to invalid location
if (size === 0 || offset >= this.bytes.length) {
this.emptyPrivateDictionary(parentDict);
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const privateDictEnd = offset + size;
const dictData = this.bytes.subarray(offset, privateDictEnd);
const dict = this.parseDict(dictData);
const privateDict = this.createDict(
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
CFFPrivateDict,
dict,
parentDict.strings
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
parentDict.privateDict = privateDict;
// Parse the Subrs index also since it's relative to the private dict.
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if (!privateDict.getByName("Subrs")) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const subrsOffset = privateDict.getByName("Subrs");
const relativeOffset = offset + subrsOffset;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// Validate the offset.
if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
this.emptyPrivateDictionary(parentDict);
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const subrsIndex = this.parseIndex(relativeOffset);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
privateDict.subrsIndex = subrsIndex.obj;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseCharsets(pos, length, strings, cid) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (pos === 0) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.ISO_ADOBE,
ISOAdobeCharset
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else if (pos === 1) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.EXPERT,
ExpertCharset
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else if (pos === 2) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.EXPERT_SUBSET,
ExpertSubsetCharset
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const bytes = this.bytes;
const start = pos;
const format = bytes[pos++];
The first glyph in CFF CIDFonts must be named 0 instead of ".notdef" Fixes #11718 in which the `ff` ligature glyph is at index zero in a CFF font. Beacuse this is a CIDFont, glyph names are CIDs, which are integers. Thus the string `".notdef"` is not correct. The rest of the charset data is already parsed correctly as integers when the boolean argument `cid` is true.
2020-03-24 22:33:43 +09:00
const charset = [cid ? 0 : ".notdef"];
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let id, count, i;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// subtract 1 for the .notdef glyph
length -= 1;
switch (format) {
case 0:
for (i = 0; i < length; i++) {
id = (bytes[pos++] << 8) | bytes[pos++];
charset.push(cid ? id : strings.get(id));
}
break;
case 1:
while (charset.length <= length) {
id = (bytes[pos++] << 8) | bytes[pos++];
count = bytes[pos++];
for (i = 0; i <= count; i++) {
charset.push(cid ? id++ : strings.get(id++));
}
}
break;
case 2:
while (charset.length <= length) {
id = (bytes[pos++] << 8) | bytes[pos++];
count = (bytes[pos++] << 8) | bytes[pos++];
for (i = 0; i <= count; i++) {
charset.push(cid ? id++ : strings.get(id++));
}
}
break;
default:
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
throw new FormatError("Unknown charset format");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
// Raw won't be needed if we actually compile the charset.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const end = pos;
const raw = bytes.subarray(start, end);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return new CFFCharset(false, format, charset, raw);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseEncoding(pos, properties, strings, charset) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const encoding = Object.create(null);
const bytes = this.bytes;
let predefined = false;
let format, i, ii;
let raw = null;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
function readSupplement() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const supplementsCount = bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 0; i < supplementsCount; i++) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const code = bytes[pos++];
const sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
encoding[code] = charset.indexOf(strings.get(sid));
}
}
if (pos === 0 || pos === 1) {
predefined = true;
format = pos;
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const baseEncoding = pos ? ExpertEncoding : StandardEncoding;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 0, ii = charset.length; i < ii; i++) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const index = baseEncoding.indexOf(charset[i]);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
if (index !== -1) {
encoding[index] = i;
}
}
} else {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const dataStart = pos;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
format = bytes[pos++];
switch (format & 0x7f) {
case 0:
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const glyphsCount = bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 1; i <= glyphsCount; i++) {
encoding[bytes[pos++]] = i;
}
break;
case 1:
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const rangesCount = bytes[pos++];
let gid = 1;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 0; i < rangesCount; i++) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const start = bytes[pos++];
const left = bytes[pos++];
for (let j = start; j <= start + left; j++) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
encoding[j] = gid++;
}
}
break;
default:
Removes error()
2017-06-29 05:51:31 +09:00
throw new FormatError(`Unknown encoding format: ${format} in CFF`);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const dataEnd = pos;
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
if (format & 0x80) {
// hasSupplement
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// The font sanitizer does not support CFF encoding with a
// supplement, since the encoding is not really used to map
// between gid to glyph, let's overwrite what is declared in
// the top dictionary to let the sanitizer think the font use
// StandardEncoding, that's a lie but that's ok.
bytes[dataStart] &= 0x7f;
readSupplement();
}
raw = bytes.subarray(dataStart, dataEnd);
}
format = format & 0x7f;
return new CFFEncoding(predefined, format, encoding, raw);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
parseFDSelect(pos, length) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const bytes = this.bytes;
const format = bytes[pos++];
const fdSelect = [];
let i;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
switch (format) {
case 0:
for (i = 0; i < length; ++i) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const id = bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
fdSelect.push(id);
}
break;
case 3:
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const rangesCount = (bytes[pos++] << 8) | bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
for (i = 0; i < rangesCount; ++i) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let first = (bytes[pos++] << 8) | bytes[pos++];
Attempt to recover valid `format 3` FDSelect data from broken CFF fonts (bug 1146106) According to the CFF specification, see http://partners.adobe.com/public/developer/en/font/5176.CFF.pdf#G3.46884, for `format 3` FDSelect data: "The first range must have a ‘first’ GID of 0". Since the PDF file (attached in the bug) violates that part of the specification, this patch tries to recover valid FDSelect data to prevent OTS from rejecting the font. Fixes https://bugzilla.mozilla.org/show_bug.cgi?id=1146106.
2016-05-27 00:34:00 +09:00
if (i === 0 && first !== 0) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
warn(
"parseFDSelect: The first range must have a first GID of 0" +
" -- trying to recover."
);
Attempt to recover valid `format 3` FDSelect data from broken CFF fonts (bug 1146106) According to the CFF specification, see http://partners.adobe.com/public/developer/en/font/5176.CFF.pdf#G3.46884, for `format 3` FDSelect data: "The first range must have a ‘first’ GID of 0". Since the PDF file (attached in the bug) violates that part of the specification, this patch tries to recover valid FDSelect data to prevent OTS from rejecting the font. Fixes https://bugzilla.mozilla.org/show_bug.cgi?id=1146106.
2016-05-27 00:34:00 +09:00
first = 0;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fdIndex = bytes[pos++];
const next = (bytes[pos] << 8) | bytes[pos + 1];
for (let j = first; j < next; ++j) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
fdSelect.push(fdIndex);
}
}
// Advance past the sentinel(next).
pos += 2;
break;
default:
Removes error()
2017-06-29 05:51:31 +09:00
throw new FormatError(`parseFDSelect: Unknown format "${format}".`);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove most `assert()` calls (issue 8506) This replaces `assert` calls with `throw new FormatError()`/`throw new Error()`. In a few places, throwing an `Error` (which is what `assert` meant) isn't correct since the enclosing function is supposed to return a `Promise`, hence some cases were changed to `Promise.reject(...)` and similarily for `createPromiseCapability` instances.
2017-07-20 21:04:54 +09:00
if (fdSelect.length !== length) {
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
throw new FormatError("parseFDSelect: Invalid font data.");
Remove most `assert()` calls (issue 8506) This replaces `assert` calls with `throw new FormatError()`/`throw new Error()`. In a few places, throwing an `Error` (which is what `assert` meant) isn't correct since the enclosing function is supposed to return a `Promise`, hence some cases were changed to `Promise.reject(...)` and similarily for `createPromiseCapability` instances.
2017-07-20 21:04:54 +09:00
}
Attempt to recover valid `format 3` FDSelect data from broken CFF fonts (bug 1146106) According to the CFF specification, see http://partners.adobe.com/public/developer/en/font/5176.CFF.pdf#G3.46884, for `format 3` FDSelect data: "The first range must have a ‘first’ GID of 0". Since the PDF file (attached in the bug) violates that part of the specification, this patch tries to recover valid FDSelect data to prevent OTS from rejecting the font. Fixes https://bugzilla.mozilla.org/show_bug.cgi?id=1146106.
2016-05-27 00:34:00 +09:00
Map all glyphs to the private use area and duplicate the first glyph. There have been lots of problems with trying to map glyphs to their unicode values. It's more reliable to just use the private use areas so the browser's font renderer doesn't mess with the glyphs. Using the private use area for all glyphs did highlight other issues that this patch also had to fix: * small private use area - Previously, only the BMP private use area was used which can't map many glyphs. Now, the (much bigger) PUP 16 area can also be used. * glyph zero not shown - Browsers will not use the glyph from a font if it is glyph id = 0. This issue was less prevalent when we mapped to unicode values since the fallback font would be used. However, when using the private use area, the glyph would not be drawn at all. This is illustrated in one of the current test cases (issue #8234) where there's an "ä" glyph at position zero. The PDF looked like it rendered correctly, but it was actually not using the glyph from the font. To properly show the first glyph it is always duplicated and appended to the glyphs and the maps are adjusted. * supplementary characters - The private use area PUP 16 is 4 bytes, so String.fromCodePoint must be used where we previously used String.fromCharCode. This is actually an issue that should have been fixed regardless of this patch. * charset - Freetype fails to load fonts when the charset size doesn't match number of glyphs in the font. We now write out a fake charset with the correct length. This also brought up the issue that glyphs with seac/endchar should only ever write a standard charset, but we now write a custom one. To get around this the seac analysis is permanently enabled so those glyphs are instead always drawn as two glyphs.
2018-01-05 07:43:07 +09:00
return new CFFFDSelect(format, fdSelect);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return CFFParser;
})();
// Compact Font Format
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFF {
constructor() {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.header = null;
this.names = [];
this.topDict = null;
this.strings = new CFFStrings();
this.globalSubrIndex = null;
// The following could really be per font, but since we only have one font
// store them here.
this.encoding = null;
this.charset = null;
this.charStrings = null;
this.fdArray = [];
this.fdSelect = null;
this.isCIDFont = false;
}
Map all glyphs to the private use area and duplicate the first glyph. There have been lots of problems with trying to map glyphs to their unicode values. It's more reliable to just use the private use areas so the browser's font renderer doesn't mess with the glyphs. Using the private use area for all glyphs did highlight other issues that this patch also had to fix: * small private use area - Previously, only the BMP private use area was used which can't map many glyphs. Now, the (much bigger) PUP 16 area can also be used. * glyph zero not shown - Browsers will not use the glyph from a font if it is glyph id = 0. This issue was less prevalent when we mapped to unicode values since the fallback font would be used. However, when using the private use area, the glyph would not be drawn at all. This is illustrated in one of the current test cases (issue #8234) where there's an "ä" glyph at position zero. The PDF looked like it rendered correctly, but it was actually not using the glyph from the font. To properly show the first glyph it is always duplicated and appended to the glyphs and the maps are adjusted. * supplementary characters - The private use area PUP 16 is 4 bytes, so String.fromCodePoint must be used where we previously used String.fromCharCode. This is actually an issue that should have been fixed regardless of this patch. * charset - Freetype fails to load fonts when the charset size doesn't match number of glyphs in the font. We now write out a fake charset with the correct length. This also brought up the issue that glyphs with seac/endchar should only ever write a standard charset, but we now write a custom one. To get around this the seac analysis is permanently enabled so those glyphs are instead always drawn as two glyphs.
2018-01-05 07:43:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
duplicateFirstGlyph() {
// Browsers will not display a glyph at position 0. Typically glyph 0 is
// notdef, but a number of fonts put a valid glyph there so it must be
// duplicated and appended.
if (this.charStrings.count >= 65535) {
warn("Not enough space in charstrings to duplicate first glyph.");
return;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const glyphZero = this.charStrings.get(0);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
this.charStrings.add(glyphZero);
if (this.isCIDFont) {
this.fdSelect.fdSelect.push(this.fdSelect.fdSelect[0]);
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
hasGlyphId(id) {
if (id < 0 || id >= this.charStrings.count) {
return false;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const glyph = this.charStrings.get(id);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
return glyph.length > 0;
}
}
class CFFHeader {
constructor(major, minor, hdrSize, offSize) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.major = major;
this.minor = minor;
this.hdrSize = hdrSize;
this.offSize = offSize;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFStrings {
constructor() {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.strings = [];
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
get(index) {
if (index >= 0 && index <= NUM_STANDARD_CFF_STRINGS - 1) {
return CFFStandardStrings[index];
}
if (index - NUM_STANDARD_CFF_STRINGS <= this.strings.length) {
return this.strings[index - NUM_STANDARD_CFF_STRINGS];
}
return CFFStandardStrings[0];
}
getSID(str) {
let index = CFFStandardStrings.indexOf(str);
if (index !== -1) {
return index;
}
index = this.strings.indexOf(str);
if (index !== -1) {
return index + NUM_STANDARD_CFF_STRINGS;
}
return -1;
}
add(value) {
this.strings.push(value);
}
get count() {
return this.strings.length;
}
}
class CFFIndex {
constructor() {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.objects = [];
this.length = 0;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
add(data) {
this.length += data.length;
this.objects.push(data);
}
set(index, data) {
this.length += data.length - this.objects[index].length;
this.objects[index] = data;
}
get(index) {
return this.objects[index];
}
get count() {
return this.objects.length;
}
}
class CFFDict {
constructor(tables, strings) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.keyToNameMap = tables.keyToNameMap;
this.nameToKeyMap = tables.nameToKeyMap;
this.defaults = tables.defaults;
this.types = tables.types;
this.opcodes = tables.opcodes;
this.order = tables.order;
this.strings = strings;
this.values = Object.create(null);
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// value should always be an array
setByKey(key, value) {
if (!(key in this.keyToNameMap)) {
return false;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const valueLength = value.length;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// ignore empty values
if (valueLength === 0) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return true;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
// Ignore invalid values (fixes bug1068432.pdf and bug1308536.pdf).
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let i = 0; i < valueLength; i++) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (isNaN(value[i])) {
warn('Invalid CFFDict value: "' + value + '" for key "' + key + '".');
return true;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const type = this.types[key];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// remove the array wrapping these types of values
if (type === "num" || type === "sid" || type === "offset") {
value = value[0];
}
this.values[key] = value;
return true;
}
setByName(name, value) {
if (!(name in this.nameToKeyMap)) {
throw new FormatError(`Invalid dictionary name "${name}"`);
}
this.values[this.nameToKeyMap[name]] = value;
}
hasName(name) {
return this.nameToKeyMap[name] in this.values;
}
getByName(name) {
if (!(name in this.nameToKeyMap)) {
throw new FormatError(`Invalid dictionary name ${name}"`);
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const key = this.nameToKeyMap[name];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (!(key in this.values)) {
return this.defaults[key];
}
return this.values[key];
}
removeByName(name) {
delete this.values[this.nameToKeyMap[name]];
}
static createTables(layout) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const tables = {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
keyToNameMap: {},
nameToKeyMap: {},
defaults: {},
types: {},
opcodes: {},
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
order: [],
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
};
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let i = 0, ii = layout.length; i < ii; ++i) {
const entry = layout[i];
const key = Array.isArray(entry[0])
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
? (entry[0][0] << 8) + entry[0][1]
: entry[0];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
tables.keyToNameMap[key] = entry[1];
tables.nameToKeyMap[entry[1]] = key;
tables.types[key] = entry[2];
tables.defaults[key] = entry[3];
Replace the `isArray` helper function with the native `Array.isArray` function *Follow-up to PR 8813.*
2017-09-02 03:27:13 +09:00
tables.opcodes[key] = Array.isArray(entry[0]) ? entry[0] : [entry[0]];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
tables.order.push(key);
}
return tables;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CFFTopDict = (function CFFTopDictClosure() {
const layout = [
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
[[12, 30], "ROS", ["sid", "sid", "num"], null],
[[12, 20], "SyntheticBase", "num", null],
[0, "version", "sid", null],
[1, "Notice", "sid", null],
[[12, 0], "Copyright", "sid", null],
[2, "FullName", "sid", null],
[3, "FamilyName", "sid", null],
[4, "Weight", "sid", null],
[[12, 1], "isFixedPitch", "num", 0],
[[12, 2], "ItalicAngle", "num", 0],
[[12, 3], "UnderlinePosition", "num", -100],
[[12, 4], "UnderlineThickness", "num", 50],
[[12, 5], "PaintType", "num", 0],
[[12, 6], "CharstringType", "num", 2],
Add `// prettier-ignore` comments to prevent re-formatting of certain data structures There's a fair number of (primarily) `Array`s/`TypedArray`s whose formatting we don't want disturb, since in many cases that would lead to the code becoming much more difficult to read and/or break existing inline comments. *Please note:* It may be a good idea to look through these cases individually, and possibly re-write some of the them (especially the `String` ones) to reduce the need for all of these ignore commands.
2019-12-25 23:54:34 +09:00
// prettier-ignore
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
[[12, 7], "FontMatrix", ["num", "num", "num", "num", "num", "num"],
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
[0.001, 0, 0, 0.001, 0, 0]],
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
[13, "UniqueID", "num", null],
[5, "FontBBox", ["num", "num", "num", "num"], [0, 0, 0, 0]],
[[12, 8], "StrokeWidth", "num", 0],
[14, "XUID", "array", null],
[15, "charset", "offset", 0],
[16, "Encoding", "offset", 0],
[17, "CharStrings", "offset", 0],
[18, "Private", ["offset", "offset"], null],
[[12, 21], "PostScript", "sid", null],
[[12, 22], "BaseFontName", "sid", null],
[[12, 23], "BaseFontBlend", "delta", null],
[[12, 31], "CIDFontVersion", "num", 0],
[[12, 32], "CIDFontRevision", "num", 0],
[[12, 33], "CIDFontType", "num", 0],
[[12, 34], "CIDCount", "num", 8720],
[[12, 35], "UIDBase", "num", null],
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// XXX: CID Fonts on DirectWrite 6.1 only seem to work if FDSelect comes
// before FDArray.
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
[[12, 37], "FDSelect", "offset", null],
[[12, 36], "FDArray", "offset", null],
[[12, 38], "FontName", "sid", null],
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
];
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let tables = null;
Whitelist closure related cases to address the remaining `no-shadow` linting errors Given the way that "classes" were previously implemented in PDF.js, using regular functions and closures, there's a fair number of false positives when the `no-shadow` ESLint rule was enabled. Note that while *some* of these `eslint-disable` statements can be removed if/when the relevant code is converted to proper `class`es, we'll probably never be able to get rid of all of them given our naming/coding conventions (however I don't really see this being a problem).
2020-03-25 18:15:50 +09:00
// eslint-disable-next-line no-shadow
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFTopDict extends CFFDict {
constructor(strings) {
if (tables === null) {
tables = CFFDict.createTables(layout);
}
super(tables, strings);
this.privateDict = null;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
return CFFTopDict;
})();
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CFFPrivateDict = (function CFFPrivateDictClosure() {
const layout = [
Enable auto-formatting of the entire code-base using Prettier (issue 11444) Note that Prettier, purposely, has only limited [configuration options](https://prettier.io/docs/en/options.html). The configuration file is based on [the one in `mozilla central`](https://searchfox.org/mozilla-central/source/.prettierrc) with just a few additions (to avoid future breakage if the defaults ever changes). Prettier is being used for a couple of reasons: - To be consistent with `mozilla-central`, where Prettier is already in use across the tree. - To ensure a *consistent* coding style everywhere, which is automatically enforced during linting (since Prettier is used as an ESLint plugin). This thus ends "all" formatting disussions once and for all, removing the need for review comments on most stylistic matters. Many ESLint options are now redundant, and I've tried my best to remove all the now unnecessary options (but I may have missed some). Note also that since Prettier considers the `printWidth` option as a guide, rather than a hard rule, this patch resorts to a small hack in the ESLint config to ensure that *comments* won't become too long. *Please note:* This patch is generated automatically, by appending the `--fix` argument to the ESLint call used in the `gulp lint` task. It will thus require some additional clean-up, which will be done in a *separate* commit. (On a more personal note, I'll readily admit that some of the changes Prettier makes are *extremely* ugly. However, in the name of consistency we'll probably have to live with that.)
2019-12-25 23:59:37 +09:00
[6, "BlueValues", "delta", null],
[7, "OtherBlues", "delta", null],
[8, "FamilyBlues", "delta", null],
[9, "FamilyOtherBlues", "delta", null],
[[12, 9], "BlueScale", "num", 0.039625],
[[12, 10], "BlueShift", "num", 7],
[[12, 11], "BlueFuzz", "num", 1],
[10, "StdHW", "num", null],
[11, "StdVW", "num", null],
[[12, 12], "StemSnapH", "delta", null],
[[12, 13], "StemSnapV", "delta", null],
[[12, 14], "ForceBold", "num", 0],
[[12, 17], "LanguageGroup", "num", 0],
[[12, 18], "ExpansionFactor", "num", 0.06],
[[12, 19], "initialRandomSeed", "num", 0],
[20, "defaultWidthX", "num", 0],
[21, "nominalWidthX", "num", 0],
[19, "Subrs", "offset", null],
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
];
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let tables = null;
Whitelist closure related cases to address the remaining `no-shadow` linting errors Given the way that "classes" were previously implemented in PDF.js, using regular functions and closures, there's a fair number of false positives when the `no-shadow` ESLint rule was enabled. Note that while *some* of these `eslint-disable` statements can be removed if/when the relevant code is converted to proper `class`es, we'll probably never be able to get rid of all of them given our naming/coding conventions (however I don't really see this being a problem).
2020-03-25 18:15:50 +09:00
// eslint-disable-next-line no-shadow
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFPrivateDict extends CFFDict {
constructor(strings) {
if (tables === null) {
tables = CFFDict.createTables(layout);
}
super(tables, strings);
this.subrsIndex = null;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
return CFFPrivateDict;
})();
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const CFFCharsetPredefinedTypes = {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
ISO_ADOBE: 0,
EXPERT: 1,
Fix inconsistent spacing and trailing commas in objects in `src/core/` files, so we can enable the `comma-dangle` and `object-curly-spacing` ESLint rules later on *Unfortunately this patch is fairly big, even though it only covers the `src/core` folder, but splitting it even further seemed difficult.* http://eslint.org/docs/rules/comma-dangle http://eslint.org/docs/rules/object-curly-spacing Given that we currently have quite inconsistent object formatting, fixing this in *one* big patch probably wouldn't be feasible (since I cannot imagine anyone wanting to review that); hence I've opted to try and do this piecewise instead. Please note: This patch was created automatically, using the ESLint --fix command line option. In a couple of places this caused lines to become too long, and I've fixed those manually; please refer to the interdiff below for the only hand-edits in this patch. ```diff diff --git a/src/core/evaluator.js b/src/core/evaluator.js index abab9027..dcd3594b 100644 --- a/src/core/evaluator.js +++ b/src/core/evaluator.js @@ -2785,7 +2785,8 @@ var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() { t['Tz'] = { id: OPS.setHScale, numArgs: 1, variableArgs: false, }; t['TL'] = { id: OPS.setLeading, numArgs: 1, variableArgs: false, }; t['Tf'] = { id: OPS.setFont, numArgs: 2, variableArgs: false, }; - t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false, }; + t['Tr'] = { id: OPS.setTextRenderingMode, numArgs: 1, + variableArgs: false, }; t['Ts'] = { id: OPS.setTextRise, numArgs: 1, variableArgs: false, }; t['Td'] = { id: OPS.moveText, numArgs: 2, variableArgs: false, }; t['TD'] = { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false, }; diff --git a/src/core/jbig2.js b/src/core/jbig2.js index 5a17d482..71671541 100644 --- a/src/core/jbig2.js +++ b/src/core/jbig2.js @@ -123,19 +123,22 @@ var Jbig2Image = (function Jbig2ImageClosure() { { x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -2, y: 0, }, { x: -1, y: 0, }], [{ x: -3, y: -1, }, { x: -2, y: -1, }, { x: -1, y: -1, }, { x: 0, y: -1, }, - { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, { x: -1, y: 0, }] + { x: 1, y: -1, }, { x: -4, y: 0, }, { x: -3, y: 0, }, { x: -2, y: 0, }, + { x: -1, y: 0, }] ]; var RefinementTemplates = [ { coding: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, - { x: 1, y: 0, }, { x: -1, y: 1, }, { x: 0, y: 1, }, { x: 1, y: 1, }], + reference: [{ x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }, + { x: 0, y: 0, }, { x: 1, y: 0, }, { x: -1, y: 1, }, + { x: 0, y: 1, }, { x: 1, y: 1, }], }, { - coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, { x: -1, y: 0, }], - reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, { x: 1, y: 0, }, - { x: 0, y: 1, }, { x: 1, y: 1, }], + coding: [{ x: -1, y: -1, }, { x: 0, y: -1, }, { x: 1, y: -1, }, + { x: -1, y: 0, }], + reference: [{ x: 0, y: -1, }, { x: -1, y: 0, }, { x: 0, y: 0, }, + { x: 1, y: 0, }, { x: 0, y: 1, }, { x: 1, y: 1, }], } ]; ```
2017-06-02 18:16:24 +09:00
EXPERT_SUBSET: 2,
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
};
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFCharset {
constructor(predefined, format, charset, raw) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.predefined = predefined;
this.format = format;
this.charset = charset;
this.raw = raw;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFEncoding {
constructor(predefined, format, encoding, raw) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.predefined = predefined;
this.format = format;
this.encoding = encoding;
this.raw = raw;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFFDSelect {
constructor(format, fdSelect) {
Map all glyphs to the private use area and duplicate the first glyph. There have been lots of problems with trying to map glyphs to their unicode values. It's more reliable to just use the private use areas so the browser's font renderer doesn't mess with the glyphs. Using the private use area for all glyphs did highlight other issues that this patch also had to fix: * small private use area - Previously, only the BMP private use area was used which can't map many glyphs. Now, the (much bigger) PUP 16 area can also be used. * glyph zero not shown - Browsers will not use the glyph from a font if it is glyph id = 0. This issue was less prevalent when we mapped to unicode values since the fallback font would be used. However, when using the private use area, the glyph would not be drawn at all. This is illustrated in one of the current test cases (issue #8234) where there's an "ä" glyph at position zero. The PDF looked like it rendered correctly, but it was actually not using the glyph from the font. To properly show the first glyph it is always duplicated and appended to the glyphs and the maps are adjusted. * supplementary characters - The private use area PUP 16 is 4 bytes, so String.fromCodePoint must be used where we previously used String.fromCharCode. This is actually an issue that should have been fixed regardless of this patch. * charset - Freetype fails to load fonts when the charset size doesn't match number of glyphs in the font. We now write out a fake charset with the correct length. This also brought up the issue that glyphs with seac/endchar should only ever write a standard charset, but we now write a custom one. To get around this the seac analysis is permanently enabled so those glyphs are instead always drawn as two glyphs.
2018-01-05 07:43:07 +09:00
this.format = format;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.fdSelect = fdSelect;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
getFDIndex(glyphIndex) {
if (glyphIndex < 0 || glyphIndex >= this.fdSelect.length) {
return -1;
}
return this.fdSelect[glyphIndex];
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// Helper class to keep track of where an offset is within the data and helps
// filling in that offset once it's known.
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
class CFFOffsetTracker {
constructor() {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.offsets = Object.create(null);
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
isTracking(key) {
return key in this.offsets;
}
Lazily initialize, and cache, the regular expression used in `CFFCompiler.encodeFloat` There's no particular reason for re-creating the regular expression over and over for every `encodeFloat` invocation, as far as I can tell.
2020-06-15 20:24:20 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
track(key, location) {
if (key in this.offsets) {
throw new FormatError(`Already tracking location of ${key}`);
}
this.offsets[key] = location;
}
offset(value) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (const key in this.offsets) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
this.offsets[key] += value;
}
}
setEntryLocation(key, values, output) {
if (!(key in this.offsets)) {
throw new FormatError(`Not tracking location of ${key}`);
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const data = output.data;
const dataOffset = this.offsets[key];
const size = 5;
for (let i = 0, ii = values.length; i < ii; ++i) {
const offset0 = i * size + dataOffset;
const offset1 = offset0 + 1;
const offset2 = offset0 + 2;
const offset3 = offset0 + 3;
const offset4 = offset0 + 4;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// It's easy to screw up offsets so perform this sanity check.
if (
data[offset0] !== 0x1d ||
data[offset1] !== 0 ||
data[offset2] !== 0 ||
data[offset3] !== 0 ||
data[offset4] !== 0
) {
throw new FormatError("writing to an offset that is not empty");
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const value = values[i];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
data[offset0] = 0x1d;
data[offset1] = (value >> 24) & 0xff;
data[offset2] = (value >> 16) & 0xff;
data[offset3] = (value >> 8) & 0xff;
data[offset4] = value & 0xff;
}
}
}
// Takes a CFF and converts it to the binary representation.
class CFFCompiler {
constructor(cff) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
this.cff = cff;
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compile() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const cff = this.cff;
const output = {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
data: [],
length: 0,
add: function CFFCompiler_add(data) {
this.data = this.data.concat(data);
this.length = this.data.length;
},
};
// Compile the five entries that must be in order.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const header = this.compileHeader(cff.header);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
output.add(header);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const nameIndex = this.compileNameIndex(cff.names);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
output.add(nameIndex);
if (cff.isCIDFont) {
// The spec is unclear on how font matrices should relate to each other
// when there is one in the main top dict and the sub top dicts.
// Windows handles this differently than linux and osx so we have to
// normalize to work on all.
// Rules based off of some mailing list discussions:
// - If main font has a matrix and subfont doesn't, use the main matrix.
// - If no main font matrix and there is a subfont matrix, use the
// subfont matrix.
// - If both have matrices, concat together.
// - If neither have matrices, use default.
// To make this work on all platforms we move the top matrix into each
// sub top dict and concat if necessary.
if (cff.topDict.hasName("FontMatrix")) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const base = cff.topDict.getByName("FontMatrix");
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
cff.topDict.removeByName("FontMatrix");
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let i = 0, ii = cff.fdArray.length; i < ii; i++) {
const subDict = cff.fdArray[i];
let matrix = base.slice(0);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (subDict.hasName("FontMatrix")) {
matrix = Util.transform(matrix, subDict.getByName("FontMatrix"));
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
subDict.setByName("FontMatrix", matrix);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Fix invalid `XUID` entries in CFF fonts In CFF fonts, entry `XUID` should be an array that has no more than 16 elements. In the issue, the length is 20, which causes the fonts to fail. See Appendix B, "Implementation Limits" in PostScript Language Reference Manual https://web.archive.org/web/20170218093716/https://www.adobe.com/products/postscript/pdfs/PLRM.pdf Actually entries `XUID` and `UniqueID` are obsolete altogether. https://blogs.adobe.com/CCJKType/2016/06/no-more-xuid-arrays.html
2020-10-05 23:38:01 +09:00
const xuid = cff.topDict.getByName("XUID");
if (xuid && xuid.length > 16) {
// Length of XUID array must not be greater than 16 (issue #12399).
cff.topDict.removeByName("XUID");
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
cff.topDict.setByName("charset", 0);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let compiled = this.compileTopDicts(
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
[cff.topDict],
output.length,
cff.isCIDFont
);
output.add(compiled.output);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const topDictTracker = compiled.trackers[0];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const stringIndex = this.compileStringIndex(cff.strings.strings);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
output.add(stringIndex);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const globalSubrIndex = this.compileIndex(cff.globalSubrIndex);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
output.add(globalSubrIndex);
// Now start on the other entries that have no specific order.
if (cff.encoding && cff.topDict.hasName("Encoding")) {
if (cff.encoding.predefined) {
topDictTracker.setEntryLocation(
"Encoding",
[cff.encoding.format],
output
);
} else {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const encoding = this.compileEncoding(cff.encoding);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
topDictTracker.setEntryLocation("Encoding", [output.length], output);
output.add(encoding);
}
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const charset = this.compileCharset(
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
cff.charset,
cff.charStrings.count,
cff.strings,
cff.isCIDFont
);
topDictTracker.setEntryLocation("charset", [output.length], output);
output.add(charset);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const charStrings = this.compileCharStrings(cff.charStrings);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
topDictTracker.setEntryLocation("CharStrings", [output.length], output);
output.add(charStrings);
if (cff.isCIDFont) {
// For some reason FDSelect must be in front of FDArray on windows. OSX
// and linux don't seem to care.
topDictTracker.setEntryLocation("FDSelect", [output.length], output);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fdSelect = this.compileFDSelect(cff.fdSelect);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
output.add(fdSelect);
// It is unclear if the sub font dictionary can have CID related
// dictionary keys, but the sanitizer doesn't like them so remove them.
compiled = this.compileTopDicts(cff.fdArray, output.length, true);
topDictTracker.setEntryLocation("FDArray", [output.length], output);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
output.add(compiled.output);
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fontDictTrackers = compiled.trackers;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
this.compilePrivateDicts([cff.topDict], [topDictTracker], output);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// If the font data ends with INDEX whose object data is zero-length,
// the sanitizer will bail out. Add a dummy byte to avoid that.
output.add([0]);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
return output.data;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
encodeNumber(value) {
if (Number.isInteger(value)) {
return this.encodeInteger(value);
}
return this.encodeFloat(value);
}
static get EncodeFloatRegExp() {
return shadow(
this,
"EncodeFloatRegExp",
/\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/
);
}
encodeFloat(num) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let value = num.toString();
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// Rounding inaccurate doubles.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const m = CFFCompiler.EncodeFloatRegExp.exec(value);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (m) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const epsilon = parseFloat("1e" + ((m[2] ? +m[2] : 0) + m[1].length));
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
value = (Math.round(num * epsilon) / epsilon).toString();
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let nibbles = "";
let i, ii;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
for (i = 0, ii = value.length; i < ii; ++i) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const a = value[i];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (a === "e") {
nibbles += value[++i] === "-" ? "c" : "b";
} else if (a === ".") {
nibbles += "a";
} else if (a === "-") {
nibbles += "e";
} else {
nibbles += a;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
nibbles += nibbles.length & 1 ? "f" : "ff";
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const out = [30];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
for (i = 0, ii = nibbles.length; i < ii; i += 2) {
out.push(parseInt(nibbles.substring(i, i + 2), 16));
}
return out;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
encodeInteger(value) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let code;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (value >= -107 && value <= 107) {
code = [value + 139];
} else if (value >= 108 && value <= 1131) {
value = value - 108;
code = [(value >> 8) + 247, value & 0xff];
} else if (value >= -1131 && value <= -108) {
value = -value - 108;
code = [(value >> 8) + 251, value & 0xff];
} else if (value >= -32768 && value <= 32767) {
code = [0x1c, (value >> 8) & 0xff, value & 0xff];
} else {
code = [
0x1d,
(value >> 24) & 0xff,
(value >> 16) & 0xff,
(value >> 8) & 0xff,
value & 0xff,
];
}
return code;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileHeader(header) {
Set CFF header to 4 when writing it because it contains 4 elements (#13149)
2021-03-27 02:23:18 +09:00
// `header.hdrSize` can be any value but we only write 4 values
// so header size is 4 (prevents OTS from rejecting the font).
return [header.major, header.minor, 4, header.offSize];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileNameIndex(names) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const nameIndex = new CFFIndex();
for (let i = 0, ii = names.length; i < ii; ++i) {
const name = names[i];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// OTS doesn't allow names to be over 127 characters.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const length = Math.min(name.length, 127);
let sanitizedName = new Array(length);
for (let j = 0; j < length; j++) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// OTS requires chars to be between a range and not certain other
// chars.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let char = name[j];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (
char < "!" ||
char > "~" ||
char === "[" ||
char === "]" ||
char === "(" ||
char === ")" ||
char === "{" ||
char === "}" ||
char === "<" ||
char === ">" ||
char === "/" ||
char === "%"
) {
char = "_";
}
sanitizedName[j] = char;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
sanitizedName = sanitizedName.join("");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (sanitizedName === "") {
sanitizedName = "Bad_Font_Name";
Lazily initialize, and cache, the regular expression used in `CFFCompiler.encodeFloat` There's no particular reason for re-creating the regular expression over and over for every `encodeFloat` invocation, as far as I can tell.
2020-06-15 20:24:20 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
nameIndex.add(stringToBytes(sanitizedName));
}
return this.compileIndex(nameIndex);
}
compileTopDicts(dicts, length, removeCidKeys) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fontDictTrackers = [];
let fdArrayIndex = new CFFIndex();
for (let i = 0, ii = dicts.length; i < ii; ++i) {
const fontDict = dicts[i];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (removeCidKeys) {
fontDict.removeByName("CIDFontVersion");
fontDict.removeByName("CIDFontRevision");
fontDict.removeByName("CIDFontType");
fontDict.removeByName("CIDCount");
fontDict.removeByName("UIDBase");
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const fontDictTracker = new CFFOffsetTracker();
const fontDictData = this.compileDict(fontDict, fontDictTracker);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
fontDictTrackers.push(fontDictTracker);
fdArrayIndex.add(fontDictData);
fontDictTracker.offset(length);
}
fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);
return {
trackers: fontDictTrackers,
output: fdArrayIndex,
};
}
compilePrivateDicts(dicts, trackers, output) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let i = 0, ii = dicts.length; i < ii; ++i) {
const fontDict = dicts[i];
const privateDict = fontDict.privateDict;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (!privateDict || !fontDict.hasName("Private")) {
throw new FormatError("There must be a private dictionary.");
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const privateDictTracker = new CFFOffsetTracker();
const privateDictData = this.compileDict(privateDict, privateDictTracker);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let outputLength = output.length;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
privateDictTracker.offset(outputLength);
if (!privateDictData.length) {
// The private dictionary was empty, set the output length to zero to
// ensure the offset length isn't out of bounds in the eyes of the
// sanitizer.
outputLength = 0;
}
trackers[i].setEntryLocation(
"Private",
[privateDictData.length, outputLength],
output
);
output.add(privateDictData);
if (privateDict.subrsIndex && privateDict.hasName("Subrs")) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const subrs = this.compileIndex(privateDict.subrsIndex);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
privateDictTracker.setEntryLocation(
"Subrs",
[privateDictData.length],
output
);
output.add(subrs);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileDict(dict, offsetTracker) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let out = [];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// The dictionary keys must be in a certain order.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const order = dict.order;
for (let i = 0; i < order.length; ++i) {
const key = order[i];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (!(key in dict.values)) {
continue;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let values = dict.values[key];
let types = dict.types[key];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (!Array.isArray(types)) {
types = [types];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (!Array.isArray(values)) {
values = [values];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Sanitize name index in compile phase of CFF. Fixes #8960
2017-10-19 10:33:35 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// Remove any empty dict values.
if (values.length === 0) {
continue;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let j = 0, jj = types.length; j < jj; ++j) {
const type = types[j];
const value = values[j];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
switch (type) {
case "num":
case "sid":
out = out.concat(this.encodeNumber(value));
break;
case "offset":
// For offsets we just insert a 32bit integer so we don't have to
// deal with figuring out the length of the offset when it gets
// replaced later on by the compiler.
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const name = dict.keyToNameMap[key];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// Some offsets have the offset and the length, so just record the
// position of the first one.
if (!offsetTracker.isTracking(name)) {
offsetTracker.track(name, out.length);
}
out = out.concat([0x1d, 0, 0, 0, 0]);
break;
case "array":
case "delta":
out = out.concat(this.encodeNumber(value));
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let k = 1, kk = values.length; k < kk; ++k) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
out = out.concat(this.encodeNumber(values[k]));
}
break;
default:
throw new FormatError(`Unknown data type of ${type}`);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
out = out.concat(dict.opcodes[key]);
}
return out;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileStringIndex(strings) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const stringIndex = new CFFIndex();
for (let i = 0, ii = strings.length; i < ii; ++i) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
stringIndex.add(stringToBytes(strings[i]));
}
return this.compileIndex(stringIndex);
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileGlobalSubrIndex() {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const globalSubrIndex = this.cff.globalSubrIndex;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
this.out.writeByteArray(this.compileIndex(globalSubrIndex));
}
compileCharStrings(charStrings) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const charStringsIndex = new CFFIndex();
for (let i = 0; i < charStrings.count; i++) {
const glyph = charStrings.get(i);
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// If the CharString outline is empty, replace it with .notdef to
// prevent OTS from rejecting the font (fixes bug1252420.pdf).
if (glyph.length === 0) {
charStringsIndex.add(new Uint8Array([0x8b, 0x0e]));
continue;
}
charStringsIndex.add(glyph);
}
return this.compileIndex(charStringsIndex);
}
compileCharset(charset, numGlyphs, strings, isCIDFont) {
// Freetype requires the number of charset strings be correct and MacOS
// requires a valid mapping for printing.
let out;
const numGlyphsLessNotDef = numGlyphs - 1;
if (isCIDFont) {
// In a CID font, the charset is a mapping of CIDs not SIDs so just
// create an identity mapping.
out = new Uint8Array([
2, // format
0, // first CID upper byte
0, // first CID lower byte
(numGlyphsLessNotDef >> 8) & 0xff,
numGlyphsLessNotDef & 0xff,
]);
} else {
const length = 1 + numGlyphsLessNotDef * 2;
out = new Uint8Array(length);
out[0] = 0; // format 0
let charsetIndex = 0;
const numCharsets = charset.charset.length;
let warned = false;
for (let i = 1; i < out.length; i += 2) {
let sid = 0;
if (charsetIndex < numCharsets) {
const name = charset.charset[charsetIndex++];
sid = strings.getSID(name);
if (sid === -1) {
sid = 0;
if (!warned) {
warned = true;
warn(`Couldn't find ${name} in CFF strings`);
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
out[i] = (sid >> 8) & 0xff;
out[i + 1] = sid & 0xff;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
return this.compileTypedArray(out);
}
compileEncoding(encoding) {
return this.compileTypedArray(encoding.raw);
}
compileFDSelect(fdSelect) {
const format = fdSelect.format;
let out, i;
switch (format) {
case 0:
out = new Uint8Array(1 + fdSelect.fdSelect.length);
out[0] = format;
for (i = 0; i < fdSelect.fdSelect.length; i++) {
out[i + 1] = fdSelect.fdSelect[i];
Map all glyphs to the private use area and duplicate the first glyph. There have been lots of problems with trying to map glyphs to their unicode values. It's more reliable to just use the private use areas so the browser's font renderer doesn't mess with the glyphs. Using the private use area for all glyphs did highlight other issues that this patch also had to fix: * small private use area - Previously, only the BMP private use area was used which can't map many glyphs. Now, the (much bigger) PUP 16 area can also be used. * glyph zero not shown - Browsers will not use the glyph from a font if it is glyph id = 0. This issue was less prevalent when we mapped to unicode values since the fallback font would be used. However, when using the private use area, the glyph would not be drawn at all. This is illustrated in one of the current test cases (issue #8234) where there's an "ä" glyph at position zero. The PDF looked like it rendered correctly, but it was actually not using the glyph from the font. To properly show the first glyph it is always duplicated and appended to the glyphs and the maps are adjusted. * supplementary characters - The private use area PUP 16 is 4 bytes, so String.fromCodePoint must be used where we previously used String.fromCharCode. This is actually an issue that should have been fixed regardless of this patch. * charset - Freetype fails to load fonts when the charset size doesn't match number of glyphs in the font. We now write out a fake charset with the correct length. This also brought up the issue that glyphs with seac/endchar should only ever write a standard charset, but we now write a custom one. To get around this the seac analysis is permanently enabled so those glyphs are instead always drawn as two glyphs.
2018-01-05 07:43:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
break;
case 3:
const start = 0;
let lastFD = fdSelect.fdSelect[0];
const ranges = [
format,
0, // nRanges place holder
0, // nRanges place holder
(start >> 8) & 0xff,
start & 0xff,
lastFD,
];
for (i = 1; i < fdSelect.fdSelect.length; i++) {
const currentFD = fdSelect.fdSelect[i];
if (currentFD !== lastFD) {
ranges.push((i >> 8) & 0xff, i & 0xff, currentFD);
lastFD = currentFD;
Add unique glyph names for CFF fonts. Printing on MacOS was broken with the previous approach of just mapping all the glyphs to notdef.
2019-02-27 08:57:46 +09:00
}
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// 3 bytes are pushed for every range and there are 3 header bytes.
const numRanges = (ranges.length - 3) / 3;
ranges[1] = (numRanges >> 8) & 0xff;
ranges[2] = numRanges & 0xff;
// sentinel
ranges.push((i >> 8) & 0xff, i & 0xff);
out = new Uint8Array(ranges);
break;
}
return this.compileTypedArray(out);
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileTypedArray(data) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const out = [];
for (let i = 0, ii = data.length; i < ii; ++i) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
out[i] = data[i];
}
return out;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
compileIndex(index, trackers = []) {
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const objects = index.objects;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// First 2 bytes contains the number of objects contained into this index
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const count = objects.length;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
// If there is no object, just create an index. This technically
// should just be [0, 0] but OTS has an issue with that.
if (count === 0) {
return [0, 0, 0];
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
const data = [(count >> 8) & 0xff, count & 0xff];
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let lastOffset = 1,
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
i;
for (i = 0; i < count; ++i) {
lastOffset += objects[i].length;
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let offsetSize;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (lastOffset < 0x100) {
offsetSize = 1;
} else if (lastOffset < 0x10000) {
offsetSize = 2;
} else if (lastOffset < 0x1000000) {
offsetSize = 3;
} else {
offsetSize = 4;
}
// Next byte contains the offset size use to reference object in the file
data.push(offsetSize);
// Add another offset after this one because we need a new offset
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
let relativeOffset = 1;
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
for (i = 0; i < count + 1; i++) {
if (offsetSize === 1) {
data.push(relativeOffset & 0xff);
} else if (offsetSize === 2) {
data.push((relativeOffset >> 8) & 0xff, relativeOffset & 0xff);
} else if (offsetSize === 3) {
data.push(
(relativeOffset >> 16) & 0xff,
(relativeOffset >> 8) & 0xff,
relativeOffset & 0xff
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
data.push(
(relativeOffset >>> 24) & 0xff,
(relativeOffset >> 16) & 0xff,
(relativeOffset >> 8) & 0xff,
relativeOffset & 0xff
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
if (objects[i]) {
relativeOffset += objects[i].length;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
for (i = 0; i < count; i++) {
// Notify the tracker where the object will be offset in the data.
if (trackers[i]) {
trackers[i].offset(data.length);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Enable the ESLint `no-var` rule in the `src/core/cff_parser.js` file Note that the majority of these changes were done automatically, by using `gulp lint --fix`, and the manual changes were limited to the following diff: ```diff diff --git a/src/core/cff_parser.js b/src/core/cff_parser.js index d684c200e..2e2b811e4 100644 --- a/src/core/cff_parser.js +++ b/src/core/cff_parser.js @@ -555,7 +555,7 @@ const CFFParser = (function CFFParserClosure() { stackSize %= 2; validationCommand = CharstringValidationData[value]; } else if (value === 10 || value === 29) { - var subrsIndex; + let subrsIndex; if (value === 10) { subrsIndex = localSubrIndex; } else { @@ -886,15 +886,15 @@ const CFFParser = (function CFFParserClosure() { format = bytes[pos++]; switch (format & 0x7f) { case 0: - var glyphsCount = bytes[pos++]; + const glyphsCount = bytes[pos++]; for (i = 1; i <= glyphsCount; i++) { encoding[bytes[pos++]] = i; } break; case 1: - var rangesCount = bytes[pos++]; - var gid = 1; + const rangesCount = bytes[pos++]; + let gid = 1; for (i = 0; i < rangesCount; i++) { const start = bytes[pos++]; const left = bytes[pos++]; @@ -938,7 +938,7 @@ const CFFParser = (function CFFParserClosure() { } break; case 3: - var rangesCount = (bytes[pos++] << 8) | bytes[pos++]; + const rangesCount = (bytes[pos++] << 8) | bytes[pos++]; for (i = 0; i < rangesCount; ++i) { let first = (bytes[pos++] << 8) | bytes[pos++]; if (i === 0 && first !== 0) { @@ -1173,7 +1173,7 @@ class CFFDict { } } -var CFFTopDict = (function CFFTopDictClosure() { +const CFFTopDict = (function CFFTopDictClosure() { const layout = [ [[12, 30], "ROS", ["sid", "sid", "num"], null], [[12, 20], "SyntheticBase", "num", null], @@ -1229,7 +1229,7 @@ var CFFTopDict = (function CFFTopDictClosure() { return CFFTopDict; })(); -var CFFPrivateDict = (function CFFPrivateDictClosure() { +const CFFPrivateDict = (function CFFPrivateDictClosure() { const layout = [ [6, "BlueValues", "delta", null], [7, "OtherBlues", "delta", null], @@ -1265,11 +1265,12 @@ var CFFPrivateDict = (function CFFPrivateDictClosure() { return CFFPrivateDict; })(); -var CFFCharsetPredefinedTypes = { +const CFFCharsetPredefinedTypes = { ISO_ADOBE: 0, EXPERT: 1, EXPERT_SUBSET: 2, }; + class CFFCharset { constructor(predefined, format, charset, raw) { this.predefined = predefined; @@ -1695,7 +1696,7 @@ class CFFCompiler { // For offsets we just insert a 32bit integer so we don't have to // deal with figuring out the length of the offset when it gets // replaced later on by the compiler. - var name = dict.keyToNameMap[key]; + const name = dict.keyToNameMap[key]; // Some offsets have the offset and the length, so just record the // position of the first one. if (!offsetTracker.isTracking(name)) { ```
2021-03-12 19:55:44 +09:00
for (let j = 0, jj = objects[i].length; j < jj; j++) {
Convert the code in `src/core/cff_parser.js` to use ES6 classes This removes multiple instances of `// eslint-disable-next-line no-shadow`, which our old pseudo-classes necessitated. *Please note:* I'm purposely not doing any `var` to `let`/`const` conversion here, since it's generally better to (if possible) do that automatically on e.g. a directory basis instead.
2020-06-16 19:33:21 +09:00
data.push(objects[i][j]);
}
}
return data;
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Convert the files in the `/src/core` folder to ES6 modules Please note that the `glyphlist.js` and `unicode.js` files are converted to CommonJS modules instead, since Babel cannot handle files that large and they are thus excluded from transpilation.
2017-04-02 23:14:30 +09:00
export {
CFF,
CFFCharset,
CFFCompiler,
Map all glyphs to the private use area and duplicate the first glyph. There have been lots of problems with trying to map glyphs to their unicode values. It's more reliable to just use the private use areas so the browser's font renderer doesn't mess with the glyphs. Using the private use area for all glyphs did highlight other issues that this patch also had to fix: * small private use area - Previously, only the BMP private use area was used which can't map many glyphs. Now, the (much bigger) PUP 16 area can also be used. * glyph zero not shown - Browsers will not use the glyph from a font if it is glyph id = 0. This issue was less prevalent when we mapped to unicode values since the fallback font would be used. However, when using the private use area, the glyph would not be drawn at all. This is illustrated in one of the current test cases (issue #8234) where there's an "ä" glyph at position zero. The PDF looked like it rendered correctly, but it was actually not using the glyph from the font. To properly show the first glyph it is always duplicated and appended to the glyphs and the maps are adjusted. * supplementary characters - The private use area PUP 16 is 4 bytes, so String.fromCodePoint must be used where we previously used String.fromCharCode. This is actually an issue that should have been fixed regardless of this patch. * charset - Freetype fails to load fonts when the charset size doesn't match number of glyphs in the font. We now write out a fake charset with the correct length. This also brought up the issue that glyphs with seac/endchar should only ever write a standard charset, but we now write a custom one. To get around this the seac analysis is permanently enabled so those glyphs are instead always drawn as two glyphs.
2018-01-05 07:43:07 +09:00
CFFFDSelect,
Use ESLint to ensure that `export`s are sorted alphabetically There's built-in ESLint rule, see `sort-imports`, to ensure that all `import`-statements are sorted alphabetically, since that often helps with readability. Unfortunately there's no corresponding rule to sort `export`-statements alphabetically, however there's an ESLint plugin which does this; please see https://www.npmjs.com/package/eslint-plugin-sort-exports The only downside here is that it's not automatically fixable, but the re-ordering is a one-time "cost" and the plugin will help maintain a *consistent* ordering of `export`-statements in the future. *Note:* To reduce the possibility of introducing any errors here, the re-ordering was done by simply selecting the relevant lines and then using the built-in sort-functionality of my editor.
2021-01-09 23:37:44 +09:00
CFFHeader,
CFFIndex,
CFFParser,
CFFPrivateDict,
CFFStandardStrings,
CFFStrings,
CFFTopDict,
Convert the files in the `/src/core` folder to ES6 modules Please note that the `glyphlist.js` and `unicode.js` files are converted to CommonJS modules instead, since Babel cannot handle files that large and they are thus excluded from transpilation.
2017-04-02 23:14:30 +09:00
};
Reference in New Issue Copy Permalink