1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 | "use strict";
|
23 |
|
24 | Object.defineProperty(exports, "__esModule", {
|
25 | value: true
|
26 | });
|
27 | exports.IdentityCMap = exports.CMapFactory = exports.CMap = void 0;
|
28 |
|
29 | var _util = require("../shared/util.js");
|
30 |
|
31 | var _primitives = require("./primitives.js");
|
32 |
|
33 | var _base_stream = require("./base_stream.js");
|
34 |
|
35 | var _parser = require("./parser.js");
|
36 |
|
37 | var _core_utils = require("./core_utils.js");
|
38 |
|
39 | var _stream = require("./stream.js");
|
40 |
|
41 | const BUILT_IN_CMAPS = ["Adobe-GB1-UCS2", "Adobe-CNS1-UCS2", "Adobe-Japan1-UCS2", "Adobe-Korea1-UCS2", "78-EUC-H", "78-EUC-V", "78-H", "78-RKSJ-H", "78-RKSJ-V", "78-V", "78ms-RKSJ-H", "78ms-RKSJ-V", "83pv-RKSJ-H", "90ms-RKSJ-H", "90ms-RKSJ-V", "90msp-RKSJ-H", "90msp-RKSJ-V", "90pv-RKSJ-H", "90pv-RKSJ-V", "Add-H", "Add-RKSJ-H", "Add-RKSJ-V", "Add-V", "Adobe-CNS1-0", "Adobe-CNS1-1", "Adobe-CNS1-2", "Adobe-CNS1-3", "Adobe-CNS1-4", "Adobe-CNS1-5", "Adobe-CNS1-6", "Adobe-GB1-0", "Adobe-GB1-1", "Adobe-GB1-2", "Adobe-GB1-3", "Adobe-GB1-4", "Adobe-GB1-5", "Adobe-Japan1-0", "Adobe-Japan1-1", "Adobe-Japan1-2", "Adobe-Japan1-3", "Adobe-Japan1-4", "Adobe-Japan1-5", "Adobe-Japan1-6", "Adobe-Korea1-0", "Adobe-Korea1-1", "Adobe-Korea1-2", "B5-H", "B5-V", "B5pc-H", "B5pc-V", "CNS-EUC-H", "CNS-EUC-V", "CNS1-H", "CNS1-V", "CNS2-H", "CNS2-V", "ETHK-B5-H", "ETHK-B5-V", "ETen-B5-H", "ETen-B5-V", "ETenms-B5-H", "ETenms-B5-V", "EUC-H", "EUC-V", "Ext-H", "Ext-RKSJ-H", "Ext-RKSJ-V", "Ext-V", "GB-EUC-H", "GB-EUC-V", "GB-H", "GB-V", "GBK-EUC-H", "GBK-EUC-V", "GBK2K-H", "GBK2K-V", "GBKp-EUC-H", "GBKp-EUC-V", "GBT-EUC-H", "GBT-EUC-V", "GBT-H", "GBT-V", "GBTpc-EUC-H", "GBTpc-EUC-V", "GBpc-EUC-H", "GBpc-EUC-V", "H", "HKdla-B5-H", "HKdla-B5-V", "HKdlb-B5-H", "HKdlb-B5-V", "HKgccs-B5-H", "HKgccs-B5-V", "HKm314-B5-H", "HKm314-B5-V", "HKm471-B5-H", "HKm471-B5-V", "HKscs-B5-H", "HKscs-B5-V", "Hankaku", "Hiragana", "KSC-EUC-H", "KSC-EUC-V", "KSC-H", "KSC-Johab-H", "KSC-Johab-V", "KSC-V", "KSCms-UHC-H", "KSCms-UHC-HW-H", "KSCms-UHC-HW-V", "KSCms-UHC-V", "KSCpc-EUC-H", "KSCpc-EUC-V", "Katakana", "NWP-H", "NWP-V", "RKSJ-H", "RKSJ-V", "Roman", "UniCNS-UCS2-H", "UniCNS-UCS2-V", "UniCNS-UTF16-H", "UniCNS-UTF16-V", "UniCNS-UTF32-H", "UniCNS-UTF32-V", "UniCNS-UTF8-H", "UniCNS-UTF8-V", "UniGB-UCS2-H", "UniGB-UCS2-V", "UniGB-UTF16-H", "UniGB-UTF16-V", "UniGB-UTF32-H", "UniGB-UTF32-V", "UniGB-UTF8-H", "UniGB-UTF8-V", "UniJIS-UCS2-H", "UniJIS-UCS2-HW-H", "UniJIS-UCS2-HW-V", "UniJIS-UCS2-V", "UniJIS-UTF16-H", "UniJIS-UTF16-V", "UniJIS-UTF32-H", "UniJIS-UTF32-V", "UniJIS-UTF8-H", "UniJIS-UTF8-V", "UniJIS2004-UTF16-H", "UniJIS2004-UTF16-V", "UniJIS2004-UTF32-H", "UniJIS2004-UTF32-V", "UniJIS2004-UTF8-H", "UniJIS2004-UTF8-V", "UniJISPro-UCS2-HW-V", "UniJISPro-UCS2-V", "UniJISPro-UTF8-V", "UniJISX0213-UTF32-H", "UniJISX0213-UTF32-V", "UniJISX02132004-UTF32-H", "UniJISX02132004-UTF32-V", "UniKS-UCS2-H", "UniKS-UCS2-V", "UniKS-UTF16-H", "UniKS-UTF16-V", "UniKS-UTF32-H", "UniKS-UTF32-V", "UniKS-UTF8-H", "UniKS-UTF8-V", "V", "WP-Symbol"];
|
42 | const MAX_MAP_RANGE = 2 ** 24 - 1;
|
43 |
|
44 | class CMap {
|
45 | constructor(builtInCMap = false) {
|
46 | this.codespaceRanges = [[], [], [], []];
|
47 | this.numCodespaceRanges = 0;
|
48 | this._map = [];
|
49 | this.name = "";
|
50 | this.vertical = false;
|
51 | this.useCMap = null;
|
52 | this.builtInCMap = builtInCMap;
|
53 | }
|
54 |
|
55 | addCodespaceRange(n, low, high) {
|
56 | this.codespaceRanges[n - 1].push(low, high);
|
57 | this.numCodespaceRanges++;
|
58 | }
|
59 |
|
60 | mapCidRange(low, high, dstLow) {
|
61 | if (high - low > MAX_MAP_RANGE) {
|
62 | throw new Error("mapCidRange - ignoring data above MAX_MAP_RANGE.");
|
63 | }
|
64 |
|
65 | while (low <= high) {
|
66 | this._map[low++] = dstLow++;
|
67 | }
|
68 | }
|
69 |
|
70 | mapBfRange(low, high, dstLow) {
|
71 | if (high - low > MAX_MAP_RANGE) {
|
72 | throw new Error("mapBfRange - ignoring data above MAX_MAP_RANGE.");
|
73 | }
|
74 |
|
75 | const lastByte = dstLow.length - 1;
|
76 |
|
77 | while (low <= high) {
|
78 | this._map[low++] = dstLow;
|
79 | const nextCharCode = dstLow.charCodeAt(lastByte) + 1;
|
80 |
|
81 | if (nextCharCode > 0xff) {
|
82 | dstLow = dstLow.substring(0, lastByte - 1) + String.fromCharCode(dstLow.charCodeAt(lastByte - 1) + 1) + "\x00";
|
83 | continue;
|
84 | }
|
85 |
|
86 | dstLow = dstLow.substring(0, lastByte) + String.fromCharCode(nextCharCode);
|
87 | }
|
88 | }
|
89 |
|
90 | mapBfRangeToArray(low, high, array) {
|
91 | if (high - low > MAX_MAP_RANGE) {
|
92 | throw new Error("mapBfRangeToArray - ignoring data above MAX_MAP_RANGE.");
|
93 | }
|
94 |
|
95 | const ii = array.length;
|
96 | let i = 0;
|
97 |
|
98 | while (low <= high && i < ii) {
|
99 | this._map[low] = array[i++];
|
100 | ++low;
|
101 | }
|
102 | }
|
103 |
|
104 | mapOne(src, dst) {
|
105 | this._map[src] = dst;
|
106 | }
|
107 |
|
108 | lookup(code) {
|
109 | return this._map[code];
|
110 | }
|
111 |
|
112 | contains(code) {
|
113 | return this._map[code] !== undefined;
|
114 | }
|
115 |
|
116 | forEach(callback) {
|
117 | const map = this._map;
|
118 | const length = map.length;
|
119 |
|
120 | if (length <= 0x10000) {
|
121 | for (let i = 0; i < length; i++) {
|
122 | if (map[i] !== undefined) {
|
123 | callback(i, map[i]);
|
124 | }
|
125 | }
|
126 | } else {
|
127 | for (const i in map) {
|
128 | callback(i, map[i]);
|
129 | }
|
130 | }
|
131 | }
|
132 |
|
133 | charCodeOf(value) {
|
134 | const map = this._map;
|
135 |
|
136 | if (map.length <= 0x10000) {
|
137 | return map.indexOf(value);
|
138 | }
|
139 |
|
140 | for (const charCode in map) {
|
141 | if (map[charCode] === value) {
|
142 | return charCode | 0;
|
143 | }
|
144 | }
|
145 |
|
146 | return -1;
|
147 | }
|
148 |
|
149 | getMap() {
|
150 | return this._map;
|
151 | }
|
152 |
|
153 | readCharCode(str, offset, out) {
|
154 | let c = 0;
|
155 | const codespaceRanges = this.codespaceRanges;
|
156 |
|
157 | for (let n = 0, nn = codespaceRanges.length; n < nn; n++) {
|
158 | c = (c << 8 | str.charCodeAt(offset + n)) >>> 0;
|
159 | const codespaceRange = codespaceRanges[n];
|
160 |
|
161 | for (let k = 0, kk = codespaceRange.length; k < kk;) {
|
162 | const low = codespaceRange[k++];
|
163 | const high = codespaceRange[k++];
|
164 |
|
165 | if (c >= low && c <= high) {
|
166 | out.charcode = c;
|
167 | out.length = n + 1;
|
168 | return;
|
169 | }
|
170 | }
|
171 | }
|
172 |
|
173 | out.charcode = 0;
|
174 | out.length = 1;
|
175 | }
|
176 |
|
177 | getCharCodeLength(charCode) {
|
178 | const codespaceRanges = this.codespaceRanges;
|
179 |
|
180 | for (let n = 0, nn = codespaceRanges.length; n < nn; n++) {
|
181 | const codespaceRange = codespaceRanges[n];
|
182 |
|
183 | for (let k = 0, kk = codespaceRange.length; k < kk;) {
|
184 | const low = codespaceRange[k++];
|
185 | const high = codespaceRange[k++];
|
186 |
|
187 | if (charCode >= low && charCode <= high) {
|
188 | return n + 1;
|
189 | }
|
190 | }
|
191 | }
|
192 |
|
193 | return 1;
|
194 | }
|
195 |
|
196 | get length() {
|
197 | return this._map.length;
|
198 | }
|
199 |
|
200 | get isIdentityCMap() {
|
201 | if (!(this.name === "Identity-H" || this.name === "Identity-V")) {
|
202 | return false;
|
203 | }
|
204 |
|
205 | if (this._map.length !== 0x10000) {
|
206 | return false;
|
207 | }
|
208 |
|
209 | for (let i = 0; i < 0x10000; i++) {
|
210 | if (this._map[i] !== i) {
|
211 | return false;
|
212 | }
|
213 | }
|
214 |
|
215 | return true;
|
216 | }
|
217 |
|
218 | }
|
219 |
|
220 | exports.CMap = CMap;
|
221 |
|
222 | class IdentityCMap extends CMap {
|
223 | constructor(vertical, n) {
|
224 | super();
|
225 | this.vertical = vertical;
|
226 | this.addCodespaceRange(n, 0, 0xffff);
|
227 | }
|
228 |
|
229 | mapCidRange(low, high, dstLow) {
|
230 | (0, _util.unreachable)("should not call mapCidRange");
|
231 | }
|
232 |
|
233 | mapBfRange(low, high, dstLow) {
|
234 | (0, _util.unreachable)("should not call mapBfRange");
|
235 | }
|
236 |
|
237 | mapBfRangeToArray(low, high, array) {
|
238 | (0, _util.unreachable)("should not call mapBfRangeToArray");
|
239 | }
|
240 |
|
241 | mapOne(src, dst) {
|
242 | (0, _util.unreachable)("should not call mapCidOne");
|
243 | }
|
244 |
|
245 | lookup(code) {
|
246 | return Number.isInteger(code) && code <= 0xffff ? code : undefined;
|
247 | }
|
248 |
|
249 | contains(code) {
|
250 | return Number.isInteger(code) && code <= 0xffff;
|
251 | }
|
252 |
|
253 | forEach(callback) {
|
254 | for (let i = 0; i <= 0xffff; i++) {
|
255 | callback(i, i);
|
256 | }
|
257 | }
|
258 |
|
259 | charCodeOf(value) {
|
260 | return Number.isInteger(value) && value <= 0xffff ? value : -1;
|
261 | }
|
262 |
|
263 | getMap() {
|
264 | const map = new Array(0x10000);
|
265 |
|
266 | for (let i = 0; i <= 0xffff; i++) {
|
267 | map[i] = i;
|
268 | }
|
269 |
|
270 | return map;
|
271 | }
|
272 |
|
273 | get length() {
|
274 | return 0x10000;
|
275 | }
|
276 |
|
277 | get isIdentityCMap() {
|
278 | (0, _util.unreachable)("should not access .isIdentityCMap");
|
279 | }
|
280 |
|
281 | }
|
282 |
|
283 | exports.IdentityCMap = IdentityCMap;
|
284 |
|
285 | const BinaryCMapReader = function BinaryCMapReaderClosure() {
|
286 | function hexToInt(a, size) {
|
287 | let n = 0;
|
288 |
|
289 | for (let i = 0; i <= size; i++) {
|
290 | n = n << 8 | a[i];
|
291 | }
|
292 |
|
293 | return n >>> 0;
|
294 | }
|
295 |
|
296 | function hexToStr(a, size) {
|
297 | if (size === 1) {
|
298 | return String.fromCharCode(a[0], a[1]);
|
299 | }
|
300 |
|
301 | if (size === 3) {
|
302 | return String.fromCharCode(a[0], a[1], a[2], a[3]);
|
303 | }
|
304 |
|
305 | return String.fromCharCode.apply(null, a.subarray(0, size + 1));
|
306 | }
|
307 |
|
308 | function addHex(a, b, size) {
|
309 | let c = 0;
|
310 |
|
311 | for (let i = size; i >= 0; i--) {
|
312 | c += a[i] + b[i];
|
313 | a[i] = c & 255;
|
314 | c >>= 8;
|
315 | }
|
316 | }
|
317 |
|
318 | function incHex(a, size) {
|
319 | let c = 1;
|
320 |
|
321 | for (let i = size; i >= 0 && c > 0; i--) {
|
322 | c += a[i];
|
323 | a[i] = c & 255;
|
324 | c >>= 8;
|
325 | }
|
326 | }
|
327 |
|
328 | const MAX_NUM_SIZE = 16;
|
329 | const MAX_ENCODED_NUM_SIZE = 19;
|
330 |
|
331 | class BinaryCMapStream {
|
332 | constructor(data) {
|
333 | this.buffer = data;
|
334 | this.pos = 0;
|
335 | this.end = data.length;
|
336 | this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);
|
337 | }
|
338 |
|
339 | readByte() {
|
340 | if (this.pos >= this.end) {
|
341 | return -1;
|
342 | }
|
343 |
|
344 | return this.buffer[this.pos++];
|
345 | }
|
346 |
|
347 | readNumber() {
|
348 | let n = 0;
|
349 | let last;
|
350 |
|
351 | do {
|
352 | const b = this.readByte();
|
353 |
|
354 | if (b < 0) {
|
355 | throw new _util.FormatError("unexpected EOF in bcmap");
|
356 | }
|
357 |
|
358 | last = !(b & 0x80);
|
359 | n = n << 7 | b & 0x7f;
|
360 | } while (!last);
|
361 |
|
362 | return n;
|
363 | }
|
364 |
|
365 | readSigned() {
|
366 | const n = this.readNumber();
|
367 | return n & 1 ? ~(n >>> 1) : n >>> 1;
|
368 | }
|
369 |
|
370 | readHex(num, size) {
|
371 | num.set(this.buffer.subarray(this.pos, this.pos + size + 1));
|
372 | this.pos += size + 1;
|
373 | }
|
374 |
|
375 | readHexNumber(num, size) {
|
376 | let last;
|
377 | const stack = this.tmpBuf;
|
378 | let sp = 0;
|
379 |
|
380 | do {
|
381 | const b = this.readByte();
|
382 |
|
383 | if (b < 0) {
|
384 | throw new _util.FormatError("unexpected EOF in bcmap");
|
385 | }
|
386 |
|
387 | last = !(b & 0x80);
|
388 | stack[sp++] = b & 0x7f;
|
389 | } while (!last);
|
390 |
|
391 | let i = size,
|
392 | buffer = 0,
|
393 | bufferSize = 0;
|
394 |
|
395 | while (i >= 0) {
|
396 | while (bufferSize < 8 && stack.length > 0) {
|
397 | buffer |= stack[--sp] << bufferSize;
|
398 | bufferSize += 7;
|
399 | }
|
400 |
|
401 | num[i] = buffer & 255;
|
402 | i--;
|
403 | buffer >>= 8;
|
404 | bufferSize -= 8;
|
405 | }
|
406 | }
|
407 |
|
408 | readHexSigned(num, size) {
|
409 | this.readHexNumber(num, size);
|
410 | const sign = num[size] & 1 ? 255 : 0;
|
411 | let c = 0;
|
412 |
|
413 | for (let i = 0; i <= size; i++) {
|
414 | c = (c & 1) << 8 | num[i];
|
415 | num[i] = c >> 1 ^ sign;
|
416 | }
|
417 | }
|
418 |
|
419 | readString() {
|
420 | const len = this.readNumber();
|
421 | let s = "";
|
422 |
|
423 | for (let i = 0; i < len; i++) {
|
424 | s += String.fromCharCode(this.readNumber());
|
425 | }
|
426 |
|
427 | return s;
|
428 | }
|
429 |
|
430 | }
|
431 |
|
432 | class BinaryCMapReader {
|
433 | async process(data, cMap, extend) {
|
434 | const stream = new BinaryCMapStream(data);
|
435 | const header = stream.readByte();
|
436 | cMap.vertical = !!(header & 1);
|
437 | let useCMap = null;
|
438 | const start = new Uint8Array(MAX_NUM_SIZE);
|
439 | const end = new Uint8Array(MAX_NUM_SIZE);
|
440 | const char = new Uint8Array(MAX_NUM_SIZE);
|
441 | const charCode = new Uint8Array(MAX_NUM_SIZE);
|
442 | const tmp = new Uint8Array(MAX_NUM_SIZE);
|
443 | let code;
|
444 | let b;
|
445 |
|
446 | while ((b = stream.readByte()) >= 0) {
|
447 | const type = b >> 5;
|
448 |
|
449 | if (type === 7) {
|
450 | switch (b & 0x1f) {
|
451 | case 0:
|
452 | stream.readString();
|
453 | break;
|
454 |
|
455 | case 1:
|
456 | useCMap = stream.readString();
|
457 | break;
|
458 | }
|
459 |
|
460 | continue;
|
461 | }
|
462 |
|
463 | const sequence = !!(b & 0x10);
|
464 | const dataSize = b & 15;
|
465 |
|
466 | if (dataSize + 1 > MAX_NUM_SIZE) {
|
467 | throw new Error("BinaryCMapReader.process: Invalid dataSize.");
|
468 | }
|
469 |
|
470 | const ucs2DataSize = 1;
|
471 | const subitemsCount = stream.readNumber();
|
472 |
|
473 | switch (type) {
|
474 | case 0:
|
475 | stream.readHex(start, dataSize);
|
476 | stream.readHexNumber(end, dataSize);
|
477 | addHex(end, start, dataSize);
|
478 | cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
|
479 |
|
480 | for (let i = 1; i < subitemsCount; i++) {
|
481 | incHex(end, dataSize);
|
482 | stream.readHexNumber(start, dataSize);
|
483 | addHex(start, end, dataSize);
|
484 | stream.readHexNumber(end, dataSize);
|
485 | addHex(end, start, dataSize);
|
486 | cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize), hexToInt(end, dataSize));
|
487 | }
|
488 |
|
489 | break;
|
490 |
|
491 | case 1:
|
492 | stream.readHex(start, dataSize);
|
493 | stream.readHexNumber(end, dataSize);
|
494 | addHex(end, start, dataSize);
|
495 | stream.readNumber();
|
496 |
|
497 | for (let i = 1; i < subitemsCount; i++) {
|
498 | incHex(end, dataSize);
|
499 | stream.readHexNumber(start, dataSize);
|
500 | addHex(start, end, dataSize);
|
501 | stream.readHexNumber(end, dataSize);
|
502 | addHex(end, start, dataSize);
|
503 | stream.readNumber();
|
504 | }
|
505 |
|
506 | break;
|
507 |
|
508 | case 2:
|
509 | stream.readHex(char, dataSize);
|
510 | code = stream.readNumber();
|
511 | cMap.mapOne(hexToInt(char, dataSize), code);
|
512 |
|
513 | for (let i = 1; i < subitemsCount; i++) {
|
514 | incHex(char, dataSize);
|
515 |
|
516 | if (!sequence) {
|
517 | stream.readHexNumber(tmp, dataSize);
|
518 | addHex(char, tmp, dataSize);
|
519 | }
|
520 |
|
521 | code = stream.readSigned() + (code + 1);
|
522 | cMap.mapOne(hexToInt(char, dataSize), code);
|
523 | }
|
524 |
|
525 | break;
|
526 |
|
527 | case 3:
|
528 | stream.readHex(start, dataSize);
|
529 | stream.readHexNumber(end, dataSize);
|
530 | addHex(end, start, dataSize);
|
531 | code = stream.readNumber();
|
532 | cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
|
533 |
|
534 | for (let i = 1; i < subitemsCount; i++) {
|
535 | incHex(end, dataSize);
|
536 |
|
537 | if (!sequence) {
|
538 | stream.readHexNumber(start, dataSize);
|
539 | addHex(start, end, dataSize);
|
540 | } else {
|
541 | start.set(end);
|
542 | }
|
543 |
|
544 | stream.readHexNumber(end, dataSize);
|
545 | addHex(end, start, dataSize);
|
546 | code = stream.readNumber();
|
547 | cMap.mapCidRange(hexToInt(start, dataSize), hexToInt(end, dataSize), code);
|
548 | }
|
549 |
|
550 | break;
|
551 |
|
552 | case 4:
|
553 | stream.readHex(char, ucs2DataSize);
|
554 | stream.readHex(charCode, dataSize);
|
555 | cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
|
556 |
|
557 | for (let i = 1; i < subitemsCount; i++) {
|
558 | incHex(char, ucs2DataSize);
|
559 |
|
560 | if (!sequence) {
|
561 | stream.readHexNumber(tmp, ucs2DataSize);
|
562 | addHex(char, tmp, ucs2DataSize);
|
563 | }
|
564 |
|
565 | incHex(charCode, dataSize);
|
566 | stream.readHexSigned(tmp, dataSize);
|
567 | addHex(charCode, tmp, dataSize);
|
568 | cMap.mapOne(hexToInt(char, ucs2DataSize), hexToStr(charCode, dataSize));
|
569 | }
|
570 |
|
571 | break;
|
572 |
|
573 | case 5:
|
574 | stream.readHex(start, ucs2DataSize);
|
575 | stream.readHexNumber(end, ucs2DataSize);
|
576 | addHex(end, start, ucs2DataSize);
|
577 | stream.readHex(charCode, dataSize);
|
578 | cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
|
579 |
|
580 | for (let i = 1; i < subitemsCount; i++) {
|
581 | incHex(end, ucs2DataSize);
|
582 |
|
583 | if (!sequence) {
|
584 | stream.readHexNumber(start, ucs2DataSize);
|
585 | addHex(start, end, ucs2DataSize);
|
586 | } else {
|
587 | start.set(end);
|
588 | }
|
589 |
|
590 | stream.readHexNumber(end, ucs2DataSize);
|
591 | addHex(end, start, ucs2DataSize);
|
592 | stream.readHex(charCode, dataSize);
|
593 | cMap.mapBfRange(hexToInt(start, ucs2DataSize), hexToInt(end, ucs2DataSize), hexToStr(charCode, dataSize));
|
594 | }
|
595 |
|
596 | break;
|
597 |
|
598 | default:
|
599 | throw new Error(`BinaryCMapReader.process - unknown type: ${type}`);
|
600 | }
|
601 | }
|
602 |
|
603 | if (useCMap) {
|
604 | return extend(useCMap);
|
605 | }
|
606 |
|
607 | return cMap;
|
608 | }
|
609 |
|
610 | }
|
611 |
|
612 | return BinaryCMapReader;
|
613 | }();
|
614 |
|
615 | const CMapFactory = function CMapFactoryClosure() {
|
616 | function strToInt(str) {
|
617 | let a = 0;
|
618 |
|
619 | for (let i = 0; i < str.length; i++) {
|
620 | a = a << 8 | str.charCodeAt(i);
|
621 | }
|
622 |
|
623 | return a >>> 0;
|
624 | }
|
625 |
|
626 | function expectString(obj) {
|
627 | if (typeof obj !== "string") {
|
628 | throw new _util.FormatError("Malformed CMap: expected string.");
|
629 | }
|
630 | }
|
631 |
|
632 | function expectInt(obj) {
|
633 | if (!Number.isInteger(obj)) {
|
634 | throw new _util.FormatError("Malformed CMap: expected int.");
|
635 | }
|
636 | }
|
637 |
|
638 | function parseBfChar(cMap, lexer) {
|
639 | while (true) {
|
640 | let obj = lexer.getObj();
|
641 |
|
642 | if (obj === _primitives.EOF) {
|
643 | break;
|
644 | }
|
645 |
|
646 | if ((0, _primitives.isCmd)(obj, "endbfchar")) {
|
647 | return;
|
648 | }
|
649 |
|
650 | expectString(obj);
|
651 | const src = strToInt(obj);
|
652 | obj = lexer.getObj();
|
653 | expectString(obj);
|
654 | const dst = obj;
|
655 | cMap.mapOne(src, dst);
|
656 | }
|
657 | }
|
658 |
|
659 | function parseBfRange(cMap, lexer) {
|
660 | while (true) {
|
661 | let obj = lexer.getObj();
|
662 |
|
663 | if (obj === _primitives.EOF) {
|
664 | break;
|
665 | }
|
666 |
|
667 | if ((0, _primitives.isCmd)(obj, "endbfrange")) {
|
668 | return;
|
669 | }
|
670 |
|
671 | expectString(obj);
|
672 | const low = strToInt(obj);
|
673 | obj = lexer.getObj();
|
674 | expectString(obj);
|
675 | const high = strToInt(obj);
|
676 | obj = lexer.getObj();
|
677 |
|
678 | if (Number.isInteger(obj) || typeof obj === "string") {
|
679 | const dstLow = Number.isInteger(obj) ? String.fromCharCode(obj) : obj;
|
680 | cMap.mapBfRange(low, high, dstLow);
|
681 | } else if ((0, _primitives.isCmd)(obj, "[")) {
|
682 | obj = lexer.getObj();
|
683 | const array = [];
|
684 |
|
685 | while (!(0, _primitives.isCmd)(obj, "]") && obj !== _primitives.EOF) {
|
686 | array.push(obj);
|
687 | obj = lexer.getObj();
|
688 | }
|
689 |
|
690 | cMap.mapBfRangeToArray(low, high, array);
|
691 | } else {
|
692 | break;
|
693 | }
|
694 | }
|
695 |
|
696 | throw new _util.FormatError("Invalid bf range.");
|
697 | }
|
698 |
|
699 | function parseCidChar(cMap, lexer) {
|
700 | while (true) {
|
701 | let obj = lexer.getObj();
|
702 |
|
703 | if (obj === _primitives.EOF) {
|
704 | break;
|
705 | }
|
706 |
|
707 | if ((0, _primitives.isCmd)(obj, "endcidchar")) {
|
708 | return;
|
709 | }
|
710 |
|
711 | expectString(obj);
|
712 | const src = strToInt(obj);
|
713 | obj = lexer.getObj();
|
714 | expectInt(obj);
|
715 | const dst = obj;
|
716 | cMap.mapOne(src, dst);
|
717 | }
|
718 | }
|
719 |
|
720 | function parseCidRange(cMap, lexer) {
|
721 | while (true) {
|
722 | let obj = lexer.getObj();
|
723 |
|
724 | if (obj === _primitives.EOF) {
|
725 | break;
|
726 | }
|
727 |
|
728 | if ((0, _primitives.isCmd)(obj, "endcidrange")) {
|
729 | return;
|
730 | }
|
731 |
|
732 | expectString(obj);
|
733 | const low = strToInt(obj);
|
734 | obj = lexer.getObj();
|
735 | expectString(obj);
|
736 | const high = strToInt(obj);
|
737 | obj = lexer.getObj();
|
738 | expectInt(obj);
|
739 | const dstLow = obj;
|
740 | cMap.mapCidRange(low, high, dstLow);
|
741 | }
|
742 | }
|
743 |
|
744 | function parseCodespaceRange(cMap, lexer) {
|
745 | while (true) {
|
746 | let obj = lexer.getObj();
|
747 |
|
748 | if (obj === _primitives.EOF) {
|
749 | break;
|
750 | }
|
751 |
|
752 | if ((0, _primitives.isCmd)(obj, "endcodespacerange")) {
|
753 | return;
|
754 | }
|
755 |
|
756 | if (typeof obj !== "string") {
|
757 | break;
|
758 | }
|
759 |
|
760 | const low = strToInt(obj);
|
761 | obj = lexer.getObj();
|
762 |
|
763 | if (typeof obj !== "string") {
|
764 | break;
|
765 | }
|
766 |
|
767 | const high = strToInt(obj);
|
768 | cMap.addCodespaceRange(obj.length, low, high);
|
769 | }
|
770 |
|
771 | throw new _util.FormatError("Invalid codespace range.");
|
772 | }
|
773 |
|
774 | function parseWMode(cMap, lexer) {
|
775 | const obj = lexer.getObj();
|
776 |
|
777 | if (Number.isInteger(obj)) {
|
778 | cMap.vertical = !!obj;
|
779 | }
|
780 | }
|
781 |
|
782 | function parseCMapName(cMap, lexer) {
|
783 | const obj = lexer.getObj();
|
784 |
|
785 | if (obj instanceof _primitives.Name) {
|
786 | cMap.name = obj.name;
|
787 | }
|
788 | }
|
789 |
|
790 | async function parseCMap(cMap, lexer, fetchBuiltInCMap, useCMap) {
|
791 | let previous, embeddedUseCMap;
|
792 |
|
793 | objLoop: while (true) {
|
794 | try {
|
795 | const obj = lexer.getObj();
|
796 |
|
797 | if (obj === _primitives.EOF) {
|
798 | break;
|
799 | } else if (obj instanceof _primitives.Name) {
|
800 | if (obj.name === "WMode") {
|
801 | parseWMode(cMap, lexer);
|
802 | } else if (obj.name === "CMapName") {
|
803 | parseCMapName(cMap, lexer);
|
804 | }
|
805 |
|
806 | previous = obj;
|
807 | } else if (obj instanceof _primitives.Cmd) {
|
808 | switch (obj.cmd) {
|
809 | case "endcmap":
|
810 | break objLoop;
|
811 |
|
812 | case "usecmap":
|
813 | if (previous instanceof _primitives.Name) {
|
814 | embeddedUseCMap = previous.name;
|
815 | }
|
816 |
|
817 | break;
|
818 |
|
819 | case "begincodespacerange":
|
820 | parseCodespaceRange(cMap, lexer);
|
821 | break;
|
822 |
|
823 | case "beginbfchar":
|
824 | parseBfChar(cMap, lexer);
|
825 | break;
|
826 |
|
827 | case "begincidchar":
|
828 | parseCidChar(cMap, lexer);
|
829 | break;
|
830 |
|
831 | case "beginbfrange":
|
832 | parseBfRange(cMap, lexer);
|
833 | break;
|
834 |
|
835 | case "begincidrange":
|
836 | parseCidRange(cMap, lexer);
|
837 | break;
|
838 | }
|
839 | }
|
840 | } catch (ex) {
|
841 | if (ex instanceof _core_utils.MissingDataException) {
|
842 | throw ex;
|
843 | }
|
844 |
|
845 | (0, _util.warn)("Invalid cMap data: " + ex);
|
846 | continue;
|
847 | }
|
848 | }
|
849 |
|
850 | if (!useCMap && embeddedUseCMap) {
|
851 | useCMap = embeddedUseCMap;
|
852 | }
|
853 |
|
854 | if (useCMap) {
|
855 | return extendCMap(cMap, fetchBuiltInCMap, useCMap);
|
856 | }
|
857 |
|
858 | return cMap;
|
859 | }
|
860 |
|
861 | async function extendCMap(cMap, fetchBuiltInCMap, useCMap) {
|
862 | cMap.useCMap = await createBuiltInCMap(useCMap, fetchBuiltInCMap);
|
863 |
|
864 | if (cMap.numCodespaceRanges === 0) {
|
865 | const useCodespaceRanges = cMap.useCMap.codespaceRanges;
|
866 |
|
867 | for (let i = 0; i < useCodespaceRanges.length; i++) {
|
868 | cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();
|
869 | }
|
870 |
|
871 | cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;
|
872 | }
|
873 |
|
874 | cMap.useCMap.forEach(function (key, value) {
|
875 | if (!cMap.contains(key)) {
|
876 | cMap.mapOne(key, cMap.useCMap.lookup(key));
|
877 | }
|
878 | });
|
879 | return cMap;
|
880 | }
|
881 |
|
882 | async function createBuiltInCMap(name, fetchBuiltInCMap) {
|
883 | if (name === "Identity-H") {
|
884 | return new IdentityCMap(false, 2);
|
885 | } else if (name === "Identity-V") {
|
886 | return new IdentityCMap(true, 2);
|
887 | }
|
888 |
|
889 | if (!BUILT_IN_CMAPS.includes(name)) {
|
890 | throw new Error("Unknown CMap name: " + name);
|
891 | }
|
892 |
|
893 | if (!fetchBuiltInCMap) {
|
894 | throw new Error("Built-in CMap parameters are not provided.");
|
895 | }
|
896 |
|
897 | const {
|
898 | cMapData,
|
899 | compressionType
|
900 | } = await fetchBuiltInCMap(name);
|
901 | const cMap = new CMap(true);
|
902 |
|
903 | if (compressionType === _util.CMapCompressionType.BINARY) {
|
904 | return new BinaryCMapReader().process(cMapData, cMap, useCMap => {
|
905 | return extendCMap(cMap, fetchBuiltInCMap, useCMap);
|
906 | });
|
907 | }
|
908 |
|
909 | if (compressionType === _util.CMapCompressionType.NONE) {
|
910 | const lexer = new _parser.Lexer(new _stream.Stream(cMapData));
|
911 | return parseCMap(cMap, lexer, fetchBuiltInCMap, null);
|
912 | }
|
913 |
|
914 | throw new Error("TODO: Only BINARY/NONE CMap compression is currently supported.");
|
915 | }
|
916 |
|
917 | return {
|
918 | async create(params) {
|
919 | const encoding = params.encoding;
|
920 | const fetchBuiltInCMap = params.fetchBuiltInCMap;
|
921 | const useCMap = params.useCMap;
|
922 |
|
923 | if (encoding instanceof _primitives.Name) {
|
924 | return createBuiltInCMap(encoding.name, fetchBuiltInCMap);
|
925 | } else if (encoding instanceof _base_stream.BaseStream) {
|
926 | const parsedCMap = await parseCMap(new CMap(), new _parser.Lexer(encoding), fetchBuiltInCMap, useCMap);
|
927 |
|
928 | if (parsedCMap.isIdentityCMap) {
|
929 | return createBuiltInCMap(parsedCMap.name, fetchBuiltInCMap);
|
930 | }
|
931 |
|
932 | return parsedCMap;
|
933 | }
|
934 |
|
935 | throw new Error("Encoding required.");
|
936 | }
|
937 |
|
938 | };
|
939 | }();
|
940 |
|
941 | exports.CMapFactory = CMapFactory; |
\ | No newline at end of file |