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

1931 lines
58 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
Correct typos
2022-04-09 09:43:18 +09:00
// Maximum subroutine call depth of type 2 charstrings. 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;
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const CharstringValidationData = [
Strip out a reserved operator (9) from CFF char strings (fixes issue #15784)
2022-12-16 19:51:23 +09:00
/* 0 */ null,
/* 1 */ { id: "hstem", min: 2, stackClearing: true, stem: true },
/* 2 */ null,
/* 3 */ { id: "vstem", min: 2, stackClearing: true, stem: true },
/* 4 */ { id: "vmoveto", min: 1, stackClearing: true },
/* 5 */ { id: "rlineto", min: 2, resetStack: true },
/* 6 */ { id: "hlineto", min: 1, resetStack: true },
/* 7 */ { id: "vlineto", min: 1, resetStack: true },
/* 8 */ { id: "rrcurveto", min: 6, resetStack: true },
/* 9 */ null,
/* 10 */ { id: "callsubr", min: 1, undefStack: true },
/* 11 */ { id: "return", min: 0, undefStack: true },
/* 12 */ null,
/* 13 */ null,
/* 14 */ { id: "endchar", min: 0, stackClearing: true },
/* 15 */ null,
/* 16 */ null,
/* 17 */ null,
/* 18 */ { id: "hstemhm", min: 2, stackClearing: true, stem: true },
/* 19 */ { id: "hintmask", min: 0, stackClearing: true },
/* 20 */ { id: "cntrmask", min: 0, stackClearing: true },
/* 21 */ { id: "rmoveto", min: 2, stackClearing: true },
/* 22 */ { id: "hmoveto", min: 1, stackClearing: true },
/* 23 */ { id: "vstemhm", min: 2, stackClearing: true, stem: true },
/* 24 */ { id: "rcurveline", min: 8, resetStack: true },
/* 25 */ { id: "rlinecurve", min: 8, resetStack: true },
/* 26 */ { id: "vvcurveto", min: 4, resetStack: true },
/* 27 */ { id: "hhcurveto", min: 4, resetStack: true },
/* 28 */ null, // shortint
/* 29 */ { id: "callgsubr", min: 1, undefStack: true },
/* 30 */ { id: "vhcurveto", min: 4, resetStack: true },
/* 31 */ { id: "hvcurveto", min: 4, resetStack: true },
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
];
const CharstringValidationData12 = [
null,
null,
null,
{ id: "and", min: 2, stackDelta: -1 },
{ id: "or", min: 2, stackDelta: -1 },
{ id: "not", min: 1, stackDelta: 0 },
null,
null,
null,
{ id: "abs", min: 1, stackDelta: 0 },
{
id: "add",
min: 2,
stackDelta: -1,
stackFn(stack, index) {
stack[index - 2] = stack[index - 2] + stack[index - 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
},
{
id: "sub",
min: 2,
stackDelta: -1,
stackFn(stack, index) {
stack[index - 2] = stack[index - 2] - stack[index - 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
},
{
id: "div",
min: 2,
stackDelta: -1,
stackFn(stack, index) {
stack[index - 2] = stack[index - 2] / stack[index - 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
},
null,
{
id: "neg",
min: 1,
stackDelta: 0,
stackFn(stack, index) {
stack[index - 1] = -stack[index - 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
},
{ id: "eq", min: 2, stackDelta: -1 },
null,
null,
{ id: "drop", min: 1, stackDelta: -1 },
null,
{ 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,
stackFn(stack, index) {
stack[index - 2] = stack[index - 2] * stack[index - 1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
},
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
},
null,
{ 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 },
null,
null,
null,
{ id: "hflex", min: 7, resetStack: true },
{ id: "flex", min: 13, resetStack: true },
{ id: "hflex1", min: 9, resetStack: true },
{ id: "flex1", min: 11, resetStack: 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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
class CFFParser {
constructor(file, properties, seacAnalysisEnabled) {
this.bytes = file.getBytes();
this.properties = properties;
this.seacAnalysisEnabled = !!seacAnalysisEnabled;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parse() {
const properties = this.properties;
const cff = new CFF();
this.cff = cff;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
// The first five sections must be in order, all the others are reached
// via offsets contained in one of the below.
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
this.parsePrivateDict(cff.topDict);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
cff.isCIDFont = topDict.hasName("ROS");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const fontMatrix = topDict.getByName("FontMatrix");
if (fontMatrix) {
properties.fontMatrix = fontMatrix;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const fontBBox = topDict.getByName("FontBBox");
if (fontBBox) {
// adjusting ascent/descent
properties.ascent = Math.max(fontBBox[3], fontBBox[1]);
properties.descent = Math.min(fontBBox[1], fontBBox[3]);
properties.ascentScaled = true;
}
let charset, encoding;
if (cff.isCIDFont) {
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(
CFFTopDict,
this.parseDict(dictRaw),
cff.strings
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
);
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
this.parsePrivateDict(fontDict);
cff.fdArray.push(fontDict);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
// cid fonts don't have an encoding
encoding = null;
charset = this.parseCharsets(
topDict.getByName("charset"),
charStringIndex.count,
cff.strings,
true
);
cff.fdSelect = this.parseFDSelect(
topDict.getByName("FDSelect"),
charStringIndex.count
);
} else {
charset = this.parseCharsets(
topDict.getByName("charset"),
charStringIndex.count,
cff.strings,
false
);
encoding = this.parseEncoding(
topDict.getByName("Encoding"),
properties,
cff.strings,
charset.charset
);
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
cff.charset = charset;
cff.encoding = encoding;
const charStringsAndSeacs = this.parseCharStrings({
charStrings: charStringIndex,
localSubrIndex: topDict.privateDict.subrsIndex,
globalSubrIndex: globalSubrIndex.obj,
fdSelect: cff.fdSelect,
fdArray: cff.fdArray,
privateDict: topDict.privateDict,
});
cff.charStrings = charStringsAndSeacs.charStrings;
cff.seacs = charStringsAndSeacs.seacs;
cff.widths = charStringsAndSeacs.widths;
return cff;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseHeader() {
let bytes = this.bytes;
const bytesLength = bytes.length;
let offset = 0;
// 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) {
throw new FormatError("Invalid CFF header");
}
if (offset !== 0) {
info("cff data is shifted");
bytes = bytes.subarray(offset);
this.bytes = bytes;
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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);
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseDict(dict) {
let pos = 0;
function parseOperand() {
let value = dict[pos++];
if (value === 30) {
return parseFloatOperand();
} 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) {
return (value - 247) * 256 + dict[pos++] + 108;
} else if (value >= 251 && value <= 254) {
return -((value - 251) * 256) - dict[pos++] - 108;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
function parseFloatOperand() {
let str = "";
const eof = 15;
// prettier-ignore
const lookup = ["0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", ".", "E", "E-", null, "-"];
const length = dict.length;
while (pos < length) {
const b = dict[pos++];
const b1 = b >> 4;
const b2 = b & 15;
if (b1 === eof) {
break;
}
str += lookup[b1];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (b2 === eof) {
break;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
str += lookup[b2];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
return parseFloat(str);
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
let operands = [];
const entries = [];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
pos = 0;
const end = dict.length;
while (pos < end) {
let b = dict[pos];
if (b <= 21) {
if (b === 12) {
b = (b << 8) | dict[++pos];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
entries.push([b, operands]);
operands = [];
++pos;
} else {
operands.push(parseOperand());
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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseIndex(pos) {
const cffIndex = new CFFIndex();
const bytes = this.bytes;
const count = (bytes[pos++] << 8) | bytes[pos++];
const offsets = [];
let end = pos;
let i, ii;
if (count !== 0) {
const offsetSize = bytes[pos++];
// add 1 for offset to determine size of last object
const startPos = pos + (count + 1) * offsetSize - 1;
for (i = 0, ii = count + 1; i < ii; ++i) {
let offset = 0;
for (let j = 0; j < offsetSize; ++j) {
offset <<= 8;
offset += bytes[pos++];
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
offsets.push(startPos + offset);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
end = offsets[count];
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
for (i = 0, ii = offsets.length - 1; i < ii; ++i) {
const offsetStart = offsets[i];
const offsetEnd = offsets[i + 1];
cffIndex.add(bytes.subarray(offsetStart, offsetEnd));
}
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseNameIndex(index) {
const names = [];
for (let i = 0, ii = index.count; i < ii; ++i) {
const name = index.get(i);
names.push(bytesToString(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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseStringIndex(index) {
const strings = new CFFStrings();
for (let i = 0, ii = index.count; i < ii; ++i) {
const data = index.get(i);
strings.add(bytesToString(data));
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
createDict(Type, dict, strings) {
const cffDict = new Type(strings);
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const [key, value] of dict) {
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
cffDict.setByKey(key, 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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseCharString(state, data, localSubrIndex, globalSubrIndex) {
if (!data || state.callDepth > MAX_SUBR_NESTING) {
return false;
}
let stackSize = state.stackSize;
const stack = state.stack;
Strip out a reserved operator (9) from CFF char strings (fixes issue #15784)
2022-12-16 19:51:23 +09:00
let length = data.length;
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
for (let j = 0; j < length; ) {
const value = data[j++];
let validationCommand = null;
if (value === 12) {
const q = data[j++];
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];
}
} else if (value === 28) {
// number (16 bit)
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);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
return false;
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
}
validationCommand = CharstringValidationData[value];
} else if (value >= 32 && value <= 246) {
// number
stack[stackSize] = value - 139;
stackSize++;
} 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;
j++;
stackSize++;
} else if (value === 255) {
// number (32 bit)
stack[stackSize] =
((data[j] << 24) |
(data[j + 1] << 16) |
(data[j + 2] << 8) |
data[j + 3]) /
65536;
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) {
let subrsIndex;
if (value === 10) {
subrsIndex = localSubrIndex;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
} else {
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
subrsIndex = globalSubrIndex;
}
if (!subrsIndex) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
validationCommand = CharstringValidationData[value];
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
warn("Missing subrsIndex for " + validationCommand.id);
return false;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
let bias = 32768;
if (subrsIndex.count < 1240) {
bias = 107;
} else if (subrsIndex.count < 33900) {
bias = 1131;
}
const subrNumber = stack[--stackSize] + bias;
if (
subrNumber < 0 ||
subrNumber >= subrsIndex.count ||
isNaN(subrNumber)
) {
validationCommand = CharstringValidationData[value];
warn("Out of bounds subrIndex for " + validationCommand.id);
return false;
}
state.stackSize = stackSize;
state.callDepth++;
const valid = this.parseCharString(
state,
subrsIndex.get(subrNumber),
localSubrIndex,
globalSubrIndex
);
if (!valid) {
return false;
}
state.callDepth--;
stackSize = state.stackSize;
continue;
} else if (value === 11) {
state.stackSize = stackSize;
return true;
} else if (value === 0 && j === data.length) {
// Operator 0 is not used according to the current spec and
// it's the last char and consequently it's likely a terminator.
// So just replace it by endchar command to make OTS happy.
data[j - 1] = 14;
validationCommand = CharstringValidationData[14];
Strip out a reserved operator (9) from CFF char strings (fixes issue #15784)
2022-12-16 19:51:23 +09:00
} else if (value === 9) {
// Not a valid value.
data.copyWithin(j - 1, j, -1);
j -= 1;
length -= 1;
continue;
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
} else {
validationCommand = CharstringValidationData[value];
}
if (validationCommand) {
if (validationCommand.stem) {
state.hints += stackSize >> 1;
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).
warn("CFF stem hints are in wrong order");
data[j - 1] = value === 1 ? 3 : 23;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
}
if ("min" in validationCommand) {
if (!state.undefStack && stackSize < validationCommand.min) {
warn(
"Not enough parameters for " +
validationCommand.id +
"; actual: " +
stackSize +
", expected: " +
validationCommand.min
);
if (stackSize === 0) {
// Just "fix" the outline in replacing command by a endchar:
// it could lead to wrong rendering of some glyphs or not.
// For example, the pdf in #6132 is well-rendered.
data[j - 1] = 14;
return true;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
return false;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
}
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) {
warn("Found too many parameters for stack-clearing command");
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (stackSize > 0) {
// Width can be any number since its the difference
// from nominalWidthX.
state.width = stack[stackSize - 1];
}
}
if ("stackDelta" in validationCommand) {
if ("stackFn" in validationCommand) {
validationCommand.stackFn(stack, stackSize);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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;
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
}
Strip out a reserved operator (9) from CFF char strings (fixes issue #15784)
2022-12-16 19:51:23 +09:00
if (length < data.length) {
data.fill(/* endchar = */ 14, length);
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseCharStrings({
charStrings,
localSubrIndex,
globalSubrIndex,
fdSelect,
fdArray,
privateDict,
}) {
const seacs = [];
const widths = [];
const count = charStrings.count;
for (let i = 0; i < count; i++) {
const charstring = charStrings.get(i);
const state = {
callDepth: 0,
stackSize: 0,
stack: [],
undefStack: true,
hints: 0,
firstStackClearing: true,
seac: null,
width: null,
hasVStems: false,
};
let valid = true;
let localSubrToUse = null;
let privateDictToUse = privateDict;
if (fdSelect && fdArray.length) {
const fdIndex = fdSelect.getFDIndex(i);
if (fdIndex === -1) {
warn("Glyph index is not in fd select.");
valid = false;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (fdIndex >= fdArray.length) {
warn("Invalid fd index for glyph index.");
valid = false;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (valid) {
privateDictToUse = fdArray[fdIndex].privateDict;
localSubrToUse = privateDictToUse.subrsIndex;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
} else if (localSubrIndex) {
localSubrToUse = localSubrIndex;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (valid) {
valid = this.parseCharString(
state,
charstring,
localSubrToUse,
globalSubrIndex
);
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (state.width !== null) {
const nominalWidth = privateDictToUse.getByName("nominalWidthX");
widths[i] = nominalWidth + state.width;
} else {
const defaultWidth = privateDictToUse.getByName("defaultWidthX");
widths[i] = defaultWidth;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (state.seac !== null) {
seacs[i] = state.seac;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (!valid) {
// resetting invalid charstring to single 'endchar'
charStrings.set(i, new Uint8Array([14]));
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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
emptyPrivateDictionary(parentDict) {
const privateDict = this.createDict(CFFPrivateDict, [], parentDict.strings);
parentDict.setByKey(18, [0, 0]);
parentDict.privateDict = privateDict;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parsePrivateDict(parentDict) {
// no private dict, do nothing
if (!parentDict.hasName("Private")) {
this.emptyPrivateDictionary(parentDict);
return;
}
const privateOffset = parentDict.getByName("Private");
// make sure the params are formatted correctly
if (!Array.isArray(privateOffset) || privateOffset.length !== 2) {
parentDict.removeByName("Private");
return;
}
const size = privateOffset[0];
const offset = privateOffset[1];
// remove empty dicts or ones that refer to invalid location
if (size === 0 || offset >= this.bytes.length) {
this.emptyPrivateDictionary(parentDict);
return;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const privateDictEnd = offset + size;
const dictData = this.bytes.subarray(offset, privateDictEnd);
const dict = this.parseDict(dictData);
const privateDict = this.createDict(
CFFPrivateDict,
dict,
parentDict.strings
);
parentDict.privateDict = privateDict;
// Parse the Subrs index also since it's relative to the private dict.
if (!privateDict.getByName("Subrs")) {
return;
}
const subrsOffset = privateDict.getByName("Subrs");
const relativeOffset = offset + subrsOffset;
// Validate the offset.
if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {
this.emptyPrivateDictionary(parentDict);
return;
}
const subrsIndex = this.parseIndex(relativeOffset);
privateDict.subrsIndex = subrsIndex.obj;
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseCharsets(pos, length, strings, cid) {
if (pos === 0) {
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.ISO_ADOBE,
ISOAdobeCharset
);
} else if (pos === 1) {
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.EXPERT,
ExpertCharset
);
} else if (pos === 2) {
return new CFFCharset(
true,
CFFCharsetPredefinedTypes.EXPERT_SUBSET,
ExpertSubsetCharset
);
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const bytes = this.bytes;
const start = pos;
const format = bytes[pos++];
const charset = [cid ? 0 : ".notdef"];
let id, count, i;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
// subtract 1 for the .notdef glyph
length -= 1;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
switch (format) {
case 0:
for (i = 0; i < length; i++) {
id = (bytes[pos++] << 8) | bytes[pos++];
charset.push(cid ? id : strings.get(id));
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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++));
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
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:
throw new FormatError("Unknown charset 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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
// Raw won't be needed if we actually compile the charset.
const end = pos;
const raw = bytes.subarray(start, end);
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseEncoding(pos, properties, strings, charset) {
const encoding = Object.create(null);
const bytes = this.bytes;
let predefined = false;
let format, i, ii;
let raw = null;
function readSupplement() {
const supplementsCount = bytes[pos++];
for (i = 0; i < supplementsCount; i++) {
const code = bytes[pos++];
const sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);
encoding[code] = charset.indexOf(strings.get(sid));
}
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
if (pos === 0 || pos === 1) {
predefined = true;
format = pos;
const baseEncoding = pos ? ExpertEncoding : StandardEncoding;
for (i = 0, ii = charset.length; i < ii; i++) {
const index = baseEncoding.indexOf(charset[i]);
if (index !== -1) {
encoding[index] = i;
}
}
} else {
const dataStart = pos;
format = bytes[pos++];
switch (format & 0x7f) {
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
case 0:
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const glyphsCount = bytes[pos++];
for (i = 1; i <= glyphsCount; i++) {
encoding[bytes[pos++]] = i;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
break;
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
case 1:
const rangesCount = bytes[pos++];
let gid = 1;
for (i = 0; i < rangesCount; i++) {
const start = bytes[pos++];
const left = bytes[pos++];
for (let j = start; j <= start + left; j++) {
encoding[j] = gid++;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
}
break;
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
default:
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const dataEnd = pos;
if (format & 0x80) {
// hasSupplement
// 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();
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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
raw = bytes.subarray(dataStart, dataEnd);
}
format &= 0x7f;
return new CFFEncoding(predefined, format, encoding, raw);
}
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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
parseFDSelect(pos, length) {
const bytes = this.bytes;
const format = bytes[pos++];
const fdSelect = [];
let i;
switch (format) {
case 0:
for (i = 0; i < length; ++i) {
const id = bytes[pos++];
fdSelect.push(id);
}
break;
case 3:
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) {
warn(
"parseFDSelect: The first range must have a first GID of 0" +
" -- trying to recover."
);
first = 0;
}
const fdIndex = bytes[pos++];
const next = (bytes[pos] << 8) | bytes[pos + 1];
for (let j = first; j < next; ++j) {
fdSelect.push(fdIndex);
}
}
// Advance past the sentinel(next).
pos += 2;
break;
default:
throw new FormatError(`parseFDSelect: Unknown format "${format}".`);
}
if (fdSelect.length !== length) {
throw new FormatError("parseFDSelect: Invalid font data.");
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 remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +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
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
}
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
// 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;
}
// ignore empty values
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
if (value.length === 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).
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const val of value) {
if (isNaN(val)) {
warn(`Invalid CFFDict value: "${value}" for key "${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
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
};
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const entry of 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 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
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
const CFFTopDictLayout = [
[[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],
// prettier-ignore
[[12, 7], "FontMatrix", ["num", "num", "num", "num", "num", "num"],
[0.001, 0, 0, 0.001, 0, 0]],
[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],
// XXX: CID Fonts on DirectWrite 6.1 only seem to work if FDSelect comes
// before FDArray.
[[12, 37], "FDSelect", "offset", null],
[[12, 36], "FDArray", "offset", null],
[[12, 38], "FontName", "sid", null],
];
class CFFTopDict extends CFFDict {
static get tables() {
return shadow(this, "tables", this.createTables(CFFTopDictLayout));
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
constructor(strings) {
super(CFFTopDict.tables, strings);
this.privateDict = null;
Extract `CFFParser` from fonts.js (issue 6777)
2016-04-01 02:53:07 +09:00
}
Remove the remaining closures in the `src/core/cff_parser.js` file Given that the code is written with JavaScript module-syntax, none of this functionality will "leak" outside of this file with these changes. For e.g. the `gulp mozcentral` command the *built* `pdf.worker.js` file-size decreases `~2 kB` with this patch, and most of the improvement comes from having less overall indentation in the code.
2022-08-14 01:19:26 +09:00
}
const CFFPrivateDictLayout = [
[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],
];
class CFFPrivateDict extends CFFDict {
static get tables() {
return shadow(this, "tables", this.createTables(CFFPrivateDictLayout));
}
constructor(strings) {
super(CFFPrivateDict.tables, strings);
this.subrsIndex = 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
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,
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
add(data) {
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.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");
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const subDict of cff.fdArray) {
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 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) {
Enable the ESLint `operator-assignment` rule This patch was generated automatically, using the `gulp lint --fix` command. Please find additional details about the ESLint rule at https://eslint.org/docs/rules/operator-assignment
2021-07-04 18:51:11 +09:00
value -= 108;
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
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();
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const name of 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
// 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();
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const fontDict of dicts) {
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) {
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
const 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.
Use more `for...of` loops in the code-base Note that these cases, which are all in older code, were found using the [`unicorn/no-for-loop`](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/no-for-loop.md) ESLint plugin rule. However, note that I've opted not to enable this rule by default since there's still *some* cases where I do think that it makes sense to allow "regular" for-loops.
2022-07-17 22:48:39 +09:00
for (const key of dict.order) {
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":
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
out.push(...this.encodeNumber(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
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);
}
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
out.push(0x1d, 0, 0, 0, 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
break;
case "array":
case "delta":
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
out.push(...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) {
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
out.push(...this.encodeNumber(values[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
}
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
}
}
Reduce unnecessary usage of `Array.prototype.concat()` There are obviously cases where using `concat` makes perfect sense, since that method doesn't change any of the existing Arrays; see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat However, in a few cases throughout the code-base that's not an issue and using `concat` only leads to unnecessary intermediate allocations. With modern JavaScript we can thus replace those with a combination of `push` and spread-syntax, which wasn't originally possible when the code was written.
2022-06-19 19:26:48 +09:00
out.push(...dict.opcodes[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
}
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();
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
for (const string of strings) {
stringIndex.add(stringToBytes(string));
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.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
Fix OTS issue with empty index (#15289)
2022-08-09 05:04:14 +09:00
// If there is no object, just create an index.
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 (count === 0) {
Fix OTS issue with empty index (#15289)
2022-08-09 05:04:14 +09:00
return [0, 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
}
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
}
Use more `for...of` loops in the code-base Most, if not all, of this code is old enough to predate the general availability of `for...of` iteration.
2022-10-03 19:33:49 +09:00
data.push(...objects[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
}
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