https://www.topology.com.tw/pdfjs/web/viewer.mjs

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2023 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * JavaScript code in this page
21 */
22
23/******/ var __webpack_modules__ = ({
24
25/***/ 588:
26/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
27
28
29// EXPORTS
30__webpack_require__.d(__webpack_exports__, {
31  FluentBundle: () => (/* reexport */ FluentBundle),
32  FluentResource: () => (/* reexport */ FluentResource)
33});
34
35// UNUSED EXPORTS: FluentDateTime, FluentNone, FluentNumber, FluentType
36
37;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/types.js
38class FluentType {
39  constructor(value) {
40    this.value = value;
41  }
42  valueOf() {
43    return this.value;
44  }
45}
46class FluentNone extends FluentType {
47  constructor(value = "???") {
48    super(value);
49  }
50  toString(scope) {
51    return `{${this.value}}`;
52  }
53}
54class FluentNumber extends FluentType {
55  constructor(value, opts = {}) {
56    super(value);
57    this.opts = opts;
58  }
59  toString(scope) {
60    try {
61      const nf = scope.memoizeIntlObject(Intl.NumberFormat, this.opts);
62      return nf.format(this.value);
63    } catch (err) {
64      scope.reportError(err);
65      return this.value.toString(10);
66    }
67  }
68}
69class FluentDateTime extends FluentType {
70  constructor(value, opts = {}) {
71    super(value);
72    this.opts = opts;
73  }
74  toString(scope) {
75    try {
76      const dtf = scope.memoizeIntlObject(Intl.DateTimeFormat, this.opts);
77      return dtf.format(this.value);
78    } catch (err) {
79      scope.reportError(err);
80      return new Date(this.value).toISOString();
81    }
82  }
83}
84;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/resolver.js
85
86const MAX_PLACEABLES = 100;
87const FSI = "\u2068";
88const PDI = "\u2069";
89function match(scope, selector, key) {
90  if (key === selector) {
91    return true;
92  }
93  if (key instanceof FluentNumber && selector instanceof FluentNumber && key.value === selector.value) {
94    return true;
95  }
96  if (selector instanceof FluentNumber && typeof key === "string") {
97    let category = scope.memoizeIntlObject(Intl.PluralRules, selector.opts).select(selector.value);
98    if (key === category) {
99      return true;
100    }
101  }
102  return false;
103}
104function getDefault(scope, variants, star) {
105  if (variants[star]) {
106    return resolvePattern(scope, variants[star].value);
107  }
108  scope.reportError(new RangeError("No default"));
109  return new FluentNone();
110}
111function getArguments(scope, args) {
112  const positional = [];
113  const named = Object.create(null);
114  for (const arg of args) {
115    if (arg.type === "narg") {
116      named[arg.name] = resolveExpression(scope, arg.value);
117    } else {
118      positional.push(resolveExpression(scope, arg));
119    }
120  }
121  return {
122    positional,
123    named
124  };
125}
126function resolveExpression(scope, expr) {
127  switch (expr.type) {
128    case "str":
129      return expr.value;
130    case "num":
131      return new FluentNumber(expr.value, {
132        minimumFractionDigits: expr.precision
133      });
134    case "var":
135      return resolveVariableReference(scope, expr);
136    case "mesg":
137      return resolveMessageReference(scope, expr);
138    case "term":
139      return resolveTermReference(scope, expr);
140    case "func":
141      return resolveFunctionReference(scope, expr);
142    case "select":
143      return resolveSelectExpression(scope, expr);
144    default:
145      return new FluentNone();
146  }
147}
148function resolveVariableReference(scope, {
149  name
150}) {
151  let arg;
152  if (scope.params) {
153    if (Object.prototype.hasOwnProperty.call(scope.params, name)) {
154      arg = scope.params[name];
155    } else {
156      return new FluentNone(`$${name}`);
157    }
158  } else if (scope.args && Object.prototype.hasOwnProperty.call(scope.args, name)) {
159    arg = scope.args[name];
160  } else {
161    scope.reportError(new ReferenceError(`Unknown variable: $${name}`));
162    return new FluentNone(`$${name}`);
163  }
164  if (arg instanceof FluentType) {
165    return arg;
166  }
167  switch (typeof arg) {
168    case "string":
169      return arg;
170    case "number":
171      return new FluentNumber(arg);
172    case "object":
173      if (arg instanceof Date) {
174        return new FluentDateTime(arg.getTime());
175      }
176    default:
177      scope.reportError(new TypeError(`Variable type not supported: $${name}, ${typeof arg}`));
178      return new FluentNone(`$${name}`);
179  }
180}
181function resolveMessageReference(scope, {
182  name,
183  attr
184}) {
185  const message = scope.bundle._messages.get(name);
186  if (!message) {
187    scope.reportError(new ReferenceError(`Unknown message: ${name}`));
188    return new FluentNone(name);
189  }
190  if (attr) {
191    const attribute = message.attributes[attr];
192    if (attribute) {
193      return resolvePattern(scope, attribute);
194    }
195    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
196    return new FluentNone(`${name}.${attr}`);
197  }
198  if (message.value) {
199    return resolvePattern(scope, message.value);
200  }
201  scope.reportError(new ReferenceError(`No value: ${name}`));
202  return new FluentNone(name);
203}
204function resolveTermReference(scope, {
205  name,
206  attr,
207  args
208}) {
209  const id = `-${name}`;
210  const term = scope.bundle._terms.get(id);
211  if (!term) {
212    scope.reportError(new ReferenceError(`Unknown term: ${id}`));
213    return new FluentNone(id);
214  }
215  if (attr) {
216    const attribute = term.attributes[attr];
217    if (attribute) {
218      scope.params = getArguments(scope, args).named;
219      const resolved = resolvePattern(scope, attribute);
220      scope.params = null;
221      return resolved;
222    }
223    scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
224    return new FluentNone(`${id}.${attr}`);
225  }
226  scope.params = getArguments(scope, args).named;
227  const resolved = resolvePattern(scope, term.value);
228  scope.params = null;
229  return resolved;
230}
231function resolveFunctionReference(scope, {
232  name,
233  args
234}) {
235  let func = scope.bundle._functions[name];
236  if (!func) {
237    scope.reportError(new ReferenceError(`Unknown function: ${name}()`));
238    return new FluentNone(`${name}()`);
239  }
240  if (typeof func !== "function") {
241    scope.reportError(new TypeError(`Function ${name}() is not callable`));
242    return new FluentNone(`${name}()`);
243  }
244  try {
245    let resolved = getArguments(scope, args);
246    return func(resolved.positional, resolved.named);
247  } catch (err) {
248    scope.reportError(err);
249    return new FluentNone(`${name}()`);
250  }
251}
252function resolveSelectExpression(scope, {
253  selector,
254  variants,
255  star
256}) {
257  let sel = resolveExpression(scope, selector);
258  if (sel instanceof FluentNone) {
259    return getDefault(scope, variants, star);
260  }
261  for (const variant of variants) {
262    const key = resolveExpression(scope, variant.key);
263    if (match(scope, sel, key)) {
264      return resolvePattern(scope, variant.value);
265    }
266  }
267  return getDefault(scope, variants, star);
268}
269function resolveComplexPattern(scope, ptn) {
270  if (scope.dirty.has(ptn)) {
271    scope.reportError(new RangeError("Cyclic reference"));
272    return new FluentNone();
273  }
274  scope.dirty.add(ptn);
275  const result = [];
276  const useIsolating = scope.bundle._useIsolating && ptn.length > 1;
277  for (const elem of ptn) {
278    if (typeof elem === "string") {
279      result.push(scope.bundle._transform(elem));
280      continue;
281    }
282    scope.placeables++;
283    if (scope.placeables > MAX_PLACEABLES) {
284      scope.dirty.delete(ptn);
285      throw new RangeError(`Too many placeables expanded: ${scope.placeables}, ` + `max allowed is ${MAX_PLACEABLES}`);
286    }
287    if (useIsolating) {
288      result.push(FSI);
289    }
290    result.push(resolveExpression(scope, elem).toString(scope));
291    if (useIsolating) {
292      result.push(PDI);
293    }
294  }
295  scope.dirty.delete(ptn);
296  return result.join("");
297}
298function resolvePattern(scope, value) {
299  if (typeof value === "string") {
300    return scope.bundle._transform(value);
301  }
302  return resolveComplexPattern(scope, value);
303}
304;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/scope.js
305class Scope {
306  constructor(bundle, errors, args) {
307    this.dirty = new WeakSet();
308    this.params = null;
309    this.placeables = 0;
310    this.bundle = bundle;
311    this.errors = errors;
312    this.args = args;
313  }
314  reportError(error) {
315    if (!this.errors || !(error instanceof Error)) {
316      throw error;
317    }
318    this.errors.push(error);
319  }
320  memoizeIntlObject(ctor, opts) {

321    let cache = this.bundle._intls.get(ctor);
322    if (!cache) {
323      cache = {};
324      this.bundle._intls.set(ctor, cache);
325    }
326    let id = JSON.stringify(opts);
327    if (!cache[id]) {
328      cache[id] = new ctor(this.bundle.locales, opts);
329    }
330    return cache[id];
331  }
332}
333;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/builtins.js
334
335function values(opts, allowed) {
336  const unwrapped = Object.create(null);
337  for (const [name, opt] of Object.entries(opts)) {
338    if (allowed.includes(name)) {
339      unwrapped[name] = opt.valueOf();
340    }
341  }
342  return unwrapped;
343}
344const NUMBER_ALLOWED = ["unitDisplay", "currencyDisplay", "useGrouping", "minimumIntegerDigits", "minimumFractionDigits", "maximumFractionDigits", "minimumSignificantDigits", "maximumSignificantDigits"];
345function NUMBER(args, opts) {
346  let arg = args[0];
347  if (arg instanceof FluentNone) {
348    return new FluentNone(`NUMBER(${arg.valueOf()})`);
349  }
350  if (arg instanceof FluentNumber) {
351    return new FluentNumber(arg.valueOf(), {
352      ...arg.opts,
353      ...values(opts, NUMBER_ALLOWED)
354    });
355  }
356  if (arg instanceof FluentDateTime) {
357    return new FluentNumber(arg.valueOf(), {
358      ...values(opts, NUMBER_ALLOWED)
359    });
360  }
361  throw new TypeError("Invalid argument to NUMBER");
362}
363const DATETIME_ALLOWED = ["dateStyle", "timeStyle", "fractionalSecondDigits", "dayPeriod", "hour12", "weekday", "era", "year", "month", "day", "hour", "minute", "second", "timeZoneName"];
364function DATETIME(args, opts) {
365  let arg = args[0];
366  if (arg instanceof FluentNone) {
367    return new FluentNone(`DATETIME(${arg.valueOf()})`);
368  }
369  if (arg instanceof FluentDateTime) {
370    return new FluentDateTime(arg.valueOf(), {
371      ...arg.opts,
372      ...values(opts, DATETIME_ALLOWED)
373    });
374  }
375  if (arg instanceof FluentNumber) {
376    return new FluentDateTime(arg.valueOf(), {
377      ...values(opts, DATETIME_ALLOWED)
378    });
379  }
380  throw new TypeError("Invalid argument to DATETIME");
381}
382;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/memoizer.js
383const cache = new Map();
384function getMemoizerForLocale(locales) {
385  const stringLocale = Array.isArray(locales) ? locales.join(" ") : locales;
386  let memoizer = cache.get(stringLocale);
387  if (memoizer === undefined) {
388    memoizer = new Map();
389    cache.set(stringLocale, memoizer);
390  }
391  return memoizer;
392}
393;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/bundle.js
394
395
396
397
398
399class FluentBundle {
400  constructor(locales, {
401    functions,
402    useIsolating = true,
403    transform = v => v
404  } = {}) {
405    this._terms = new Map();
406    this._messages = new Map();
407    this.locales = Array.isArray(locales) ? locales : [locales];
408    this._functions = {
409      NUMBER: NUMBER,
410      DATETIME: DATETIME,
411      ...functions
412    };
413    this._useIsolating = useIsolating;
414    this._transform = transform;
415    this._intls = getMemoizerForLocale(locales);
416  }
417  hasMessage(id) {
418    return this._messages.has(id);
419  }
420  getMessage(id) {
421    return this._messages.get(id);
422  }
423  addResource(res, {
424    allowOverrides = false
425  } = {}) {
426    const errors = [];
427    for (let i = 0; i < res.body.length; i++) {
428      let entry = res.body[i];
429      if (entry.id.startsWith("-")) {
430        if (allowOverrides === false && this._terms.has(entry.id)) {
431          errors.push(new Error(`Attempt to override an existing term: "${entry.id}"`));
432          continue;
433        }
434        this._terms.set(entry.id, entry);
435      } else {
436        if (allowOverrides === false && this._messages.has(entry.id)) {
437          errors.push(new Error(`Attempt to override an existing message: "${entry.id}"`));
438          continue;
439        }
440        this._messages.set(entry.id, entry);
441      }
442    }
443    return errors;
444  }
445  formatPattern(pattern, args = null, errors = null) {
446    if (typeof pattern === "string") {
447      return this._transform(pattern);
448    }
449    let scope = new Scope(this, errors, args);
450    try {
451      let value = resolveComplexPattern(scope, pattern);
452      return value.toString(scope);
453    } catch (err) {
454      if (scope.errors && err instanceof Error) {
455        scope.errors.push(err);
456        return new FluentNone().toString(scope);
457      }
458      throw err;
459    }
460  }
461}
462;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/resource.js

463const RE_MESSAGE_START = /^(-?[a-zA-Z][\w-]*) *= */gm;
464const RE_ATTRIBUTE_START = /\.([a-zA-Z][\w-]*) *= */y;
465const RE_VARIANT_START = /\*?\[/y;
466const RE_NUMBER_LITERAL = /(-?[0-9]+(?:\.([0-9]+))?)/y;
467const RE_IDENTIFIER = /([a-zA-Z][\w-]*)/y;
468const RE_REFERENCE = /([$-])?([a-zA-Z][\w-]*)(?:\.([a-zA-Z][\w-]*))?/y;
469const RE_FUNCTION_NAME = /^[A-Z][A-Z0-9_-]*$/;
470const RE_TEXT_RUN = /([^{}\n\r]+)/y;
471const RE_STRING_RUN = /([^\\"\n\r]*)/y;
472const RE_STRING_ESCAPE = /\\([\\"])/y;
473const RE_UNICODE_ESCAPE = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{6})/y;
474const RE_LEADING_NEWLINES = /^\n+/;
475const RE_TRAILING_SPACES = / +$/;
476const RE_BLANK_LINES = / *\r?\n/g;
477const RE_INDENT = /( *)$/;
478const TOKEN_BRACE_OPEN = /{\s*/y;
479const TOKEN_BRACE_CLOSE = /\s*}/y;
480const TOKEN_BRACKET_OPEN = /\[\s*/y;
481const TOKEN_BRACKET_CLOSE = /\s*] */y;
482const TOKEN_PAREN_OPEN = /\s*\(\s*/y;
483const TOKEN_ARROW = /\s*->\s*/y;
484const TOKEN_COLON = /\s*:\s*/y;
485const TOKEN_COMMA = /\s*,?\s*/y;
486const TOKEN_BLANK = /\s+/y;
487class FluentResource {
488  constructor(source) {
489    this.body = [];
490    RE_MESSAGE_START.lastIndex = 0;
491    let cursor = 0;
492    while (true) {
493      let next = RE_MESSAGE_START.exec(source);
494      if (next === null) {
495        break;
496      }
497      cursor = RE_MESSAGE_START.lastIndex;
498      try {
499        this.body.push(parseMessage(next[1]));
500      } catch (err) {
501        if (err instanceof SyntaxError) {
502          continue;
503        }
504        throw err;
505      }
506    }
507    function test(re) {
508      re.lastIndex = cursor;
509      return re.test(source);
510    }
511    function consumeChar(char, errorClass) {
512      if (source[cursor] === char) {
513        cursor++;
514        return true;
515      }
516      if (errorClass) {
517        throw new errorClass(`Expected ${char}`);
518      }
519      return false;
520    }
521    function consumeToken(re, errorClass) {
522      if (test(re)) {
523        cursor = re.lastIndex;
524        return true;
525      }
526      if (errorClass) {
527        throw new errorClass(`Expected ${re.toString()}`);
528      }
529      return false;
530    }
531    function match(re) {
532      re.lastIndex = cursor;
533      let result = re.exec(source);
534      if (result === null) {
535        throw new SyntaxError(`Expected ${re.toString()}`);
536      }
537      cursor = re.lastIndex;
538      return result;
539    }
540    function match1(re) {
541      return match(re)[1];
542    }
543    function parseMessage(id) {
544      let value = parsePattern();
545      let attributes = parseAttributes();
546      if (value === null && Object.keys(attributes).length === 0) {
547        throw new SyntaxError("Expected message value or attributes");
548      }
549      return {
550        id,
551        value,
552        attributes
553      };
554    }
555    function parseAttributes() {
556      let attrs = Object.create(null);
557      while (test(RE_ATTRIBUTE_START)) {
558        let name = match1(RE_ATTRIBUTE_START);
559        let value = parsePattern();
560        if (value === null) {
561          throw new SyntaxError("Expected attribute value");
562        }
563        attrs[name] = value;
564      }
565      return attrs;
566    }
567    function parsePattern() {
568      let first;
569      if (test(RE_TEXT_RUN)) {
570        first = match1(RE_TEXT_RUN);
571      }
572      if (source[cursor] === "{" || source[cursor] === "}") {
573        return parsePatternElements(first ? [first] : [], Infinity);
574      }
575      let indent = parseIndent();
576      if (indent) {
577        if (first) {
578          return parsePatternElements([first, indent], indent.length);
579        }
580        indent.value = trim(indent.value, RE_LEADING_NEWLINES);
581        return parsePatternElements([indent], indent.length);
582      }
583      if (first) {
584        return trim(first, RE_TRAILING_SPACES);
585      }
586      return null;
587    }
588    function parsePatternElements(elements = [], commonIndent) {
589      while (true) {
590        if (test(RE_TEXT_RUN)) {
591          elements.push(match1(RE_TEXT_RUN));
592          continue;
593        }
594        if (source[cursor] === "{") {
595          elements.push(parsePlaceable());
596          continue;
597        }
598        if (source[cursor] === "}") {
599          throw new SyntaxError("Unbalanced closing brace");
600        }
601        let indent = parseIndent();
602        if (indent) {
603          elements.push(indent);
604          commonIndent = Math.min(commonIndent, indent.length);
605          continue;
606        }
607        break;
608      }
609      let lastIndex = elements.length - 1;
610      let lastElement = elements[lastIndex];
611      if (typeof lastElement === "string") {
612        elements[lastIndex] = trim(lastElement, RE_TRAILING_SPACES);
613      }
614      let baked = [];
615      for (let element of elements) {
616        if (element instanceof Indent) {
617          element = element.value.slice(0, element.value.length - commonIndent);
618        }
619        if (element) {
620          baked.push(element);
621        }
622      }
623      return baked;
624    }
625    function parsePlaceable() {
626      consumeToken(TOKEN_BRACE_OPEN, SyntaxError);
627      let selector = parseInlineExpression();
628      if (consumeToken(TOKEN_BRACE_CLOSE)) {
629        return selector;
630      }
631      if (consumeToken(TOKEN_ARROW)) {
632        let variants = parseVariants();
633        consumeToken(TOKEN_BRACE_CLOSE, SyntaxError);
634        return {
635          type: "select",
636          selector,
637          ...variants
638        };
639      }
640      throw new SyntaxError("Unclosed placeable");
641    }
642    function parseInlineExpression() {
643      if (source[cursor] === "{") {
644        return parsePlaceable();
645      }
646      if (test(RE_REFERENCE)) {
647        let [, sigil, name, attr = null] = match(RE_REFERENCE);
648        if (sigil === "$") {
649          return {
650            type: "var",
651            name
652          };
653        }
654        if (consumeToken(TOKEN_PAREN_OPEN)) {
655          let args = parseArguments();
656          if (sigil === "-") {
657            return {
658              type: "term",
659              name,
660              attr,
661              args
662            };
663          }
664          if (RE_FUNCTION_NAME.test(name)) {
665            return {
666              type: "func",
667              name,
668              args
669            };
670          }
671          throw new SyntaxError("Function names must be all upper-case");
672        }
673        if (sigil === "-") {
674          return {
675            type: "term",
676            name,
677            attr,
678            args: []
679          };
680        }
681        return {
682          type: "mesg",
683          name,
684          attr
685        };
686      }
687      return parseLiteral();
688    }
689    function parseArguments() {
690      let args = [];
691      while (true) {
692        switch (source[cursor]) {
693          case ")":
694            cursor++;
695            return args;
696          case undefined:
697            throw new SyntaxError("Unclosed argument list");
698        }
699        args.push(parseArgument());
700        consumeToken(TOKEN_COMMA);
701      }
702    }
703    function parseArgument() {
704      let expr = parseInlineExpression();
705      if (expr.type !== "mesg") {
706        return expr;
707      }
708      if (consumeToken(TOKEN_COLON)) {
709        return {
710          type: "narg",
711          name: expr.name,
712          value: parseLiteral()
713        };
714      }
715      return expr;
716    }
717    function parseVariants() {
718      let variants = [];
719      let count = 0;
720      let star;
721      while (test(RE_VARIANT_START)) {

722        if (consumeChar("*")) {
723          star = count;
724        }
725        let key = parseVariantKey();
726        let value = parsePattern();
727        if (value === null) {
728          throw new SyntaxError("Expected variant value");
729        }
730        variants[count++] = {
731          key,
732          value
733        };
734      }
735      if (count === 0) {
736        return null;
737      }
738      if (star === undefined) {
739        throw new SyntaxError("Expected default variant");
740      }
741      return {
742        variants,
743        star
744      };
745    }
746    function parseVariantKey() {
747      consumeToken(TOKEN_BRACKET_OPEN, SyntaxError);
748      let key;
749      if (test(RE_NUMBER_LITERAL)) {
750        key = parseNumberLiteral();
751      } else {
752        key = {
753          type: "str",
754          value: match1(RE_IDENTIFIER)
755        };
756      }
757      consumeToken(TOKEN_BRACKET_CLOSE, SyntaxError);
758      return key;
759    }
760    function parseLiteral() {
761      if (test(RE_NUMBER_LITERAL)) {
762        return parseNumberLiteral();
763      }
764      if (source[cursor] === '"') {
765        return parseStringLiteral();
766      }
767      throw new SyntaxError("Invalid expression");
768    }
769    function parseNumberLiteral() {
770      let [, value, fraction = ""] = match(RE_NUMBER_LITERAL);
771      let precision = fraction.length;
772      return {
773        type: "num",
774        value: parseFloat(value),
775        precision
776      };
777    }
778    function parseStringLiteral() {
779      consumeChar('"', SyntaxError);
780      let value = "";
781      while (true) {
782        value += match1(RE_STRING_RUN);
783        if (source[cursor] === "\\") {
784          value += parseEscapeSequence();
785          continue;
786        }
787        if (consumeChar('"')) {
788          return {
789            type: "str",
790            value
791          };
792        }
793        throw new SyntaxError("Unclosed string literal");
794      }
795    }
796    function parseEscapeSequence() {
797      if (test(RE_STRING_ESCAPE)) {
798        return match1(RE_STRING_ESCAPE);
799      }
800      if (test(RE_UNICODE_ESCAPE)) {
801        let [, codepoint4, codepoint6] = match(RE_UNICODE_ESCAPE);
802        let codepoint = parseInt(codepoint4 || codepoint6, 16);
803        return codepoint <= 0xd7ff || 0xe000 <= codepoint ? String.fromCodePoint(codepoint) : "�";
804      }
805      throw new SyntaxError("Unknown escape sequence");
806    }
807    function parseIndent() {
808      let start = cursor;
809      consumeToken(TOKEN_BLANK);
810      switch (source[cursor]) {
811        case ".":
812        case "[":
813        case "*":
814        case "}":
815        case undefined:
816          return false;
817        case "{":
818          return makeIndent(source.slice(start, cursor));
819      }
820      if (source[cursor - 1] === " ") {
821        return makeIndent(source.slice(start, cursor));
822      }
823      return false;
824    }
825    function trim(text, re) {
826      return text.replace(re, "");
827    }
828    function makeIndent(blank) {
829      let value = blank.replace(RE_BLANK_LINES, "\n");
830      let length = RE_INDENT.exec(blank)[1].length;
831      return new Indent(value, length);
832    }
833  }
834}
835class Indent {
836  constructor(value, length) {
837    this.value = value;
838    this.length = length;
839  }
840}
841;// CONCATENATED MODULE: ./node_modules/@fluent/bundle/esm/index.js
842
843
844
845
846/***/ }),
847
848/***/ 5273:
849/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
850
851
852// EXPORTS
853__webpack_require__.d(__webpack_exports__, {
854  DOMLocalization: () => (/* reexport */ DOMLocalization)
855});
856
857// UNUSED EXPORTS: Localization
858
859;// CONCATENATED MODULE: ./node_modules/@fluent/dom/esm/overlay.js
860const reOverlay = /<|&#?\w+;/;
861const TEXT_LEVEL_ELEMENTS = {
862  "http://www.w3.org/1999/xhtml": ["em", "strong", "small", "s", "cite", "q", "dfn", "abbr", "data", "time", "code", "var", "samp", "kbd", "sub", "sup", "i", "b", "u", "mark", "bdi", "bdo", "span", "br", "wbr"]
863};
864const LOCALIZABLE_ATTRIBUTES = {
865  "http://www.w3.org/1999/xhtml": {
866    global: ["title", "aria-label", "aria-valuetext"],
867    a: ["download"],
868    area: ["download", "alt"],
869    input: ["alt", "placeholder"],
870    menuitem: ["label"],
871    menu: ["label"],
872    optgroup: ["label"],
873    option: ["label"],
874    track: ["label"],
875    img: ["alt"],
876    textarea: ["placeholder"],
877    th: ["abbr"]
878  },
879  "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul": {
880    global: ["accesskey", "aria-label", "aria-valuetext", "label", "title", "tooltiptext"],
881    description: ["value"],
882    key: ["key", "keycode"],
883    label: ["value"],
884    textbox: ["placeholder", "value"]
885  }
886};
887function translateElement(element, translation) {
888  const {
889    value
890  } = translation;
891  if (typeof value === "string") {
892    if (element.localName === "title" && element.namespaceURI === "http://www.w3.org/1999/xhtml") {
893      element.textContent = value;
894    } else if (!reOverlay.test(value)) {
895      element.textContent = value;
896    } else {
897      const templateElement = element.ownerDocument.createElementNS("http://www.w3.org/1999/xhtml", "template");
898      templateElement.innerHTML = value;
899      overlayChildNodes(templateElement.content, element);
900    }
901  }
902  overlayAttributes(translation, element);
903}
904function overlayChildNodes(fromFragment, toElement) {
905  for (const childNode of fromFragment.childNodes) {
906    if (childNode.nodeType === childNode.TEXT_NODE) {
907      continue;
908    }
909    if (childNode.hasAttribute("data-l10n-name")) {
910      const sanitized = getNodeForNamedElement(toElement, childNode);
911      fromFragment.replaceChild(sanitized, childNode);
912      continue;
913    }
914    if (isElementAllowed(childNode)) {
915      const sanitized = createSanitizedElement(childNode);
916      fromFragment.replaceChild(sanitized, childNode);
917      continue;
918    }
919    console.warn(`An element of forbidden type "${childNode.localName}" was found in ` + "the translation. Only safe text-level elements and elements with " + "data-l10n-name are allowed.");
920    fromFragment.replaceChild(createTextNodeFromTextContent(childNode), childNode);
921  }
922  toElement.textContent = "";
923  toElement.appendChild(fromFragment);
924}
925function hasAttribute(attributes, name) {
926  if (!attributes) {
927    return false;

928  }
929  for (let attr of attributes) {
930    if (attr.name === name) {
931      return true;
932    }
933  }
934  return false;
935}
936function overlayAttributes(fromElement, toElement) {
937  const explicitlyAllowed = toElement.hasAttribute("data-l10n-attrs") ? toElement.getAttribute("data-l10n-attrs").split(",").map(i => i.trim()) : null;
938  for (const attr of Array.from(toElement.attributes)) {
939    if (isAttrNameLocalizable(attr.name, toElement, explicitlyAllowed) && !hasAttribute(fromElement.attributes, attr.name)) {
940      toElement.removeAttribute(attr.name);
941    }
942  }
943  if (!fromElement.attributes) {
944    return;
945  }
946  for (const attr of Array.from(fromElement.attributes)) {
947    if (isAttrNameLocalizable(attr.name, toElement, explicitlyAllowed) && toElement.getAttribute(attr.name) !== attr.value) {
948      toElement.setAttribute(attr.name, attr.value);
949    }
950  }
951}
952function getNodeForNamedElement(sourceElement, translatedChild) {
953  const childName = translatedChild.getAttribute("data-l10n-name");
954  const sourceChild = sourceElement.querySelector(`[data-l10n-name="${childName}"]`);
955  if (!sourceChild) {
956    console.warn(`An element named "${childName}" wasn't found in the source.`);
957    return createTextNodeFromTextContent(translatedChild);
958  }
959  if (sourceChild.localName !== translatedChild.localName) {
960    console.warn(`An element named "${childName}" was found in the translation ` + `but its type ${translatedChild.localName} didn't match the ` + `element found in the source (${sourceChild.localName}).`);
961    return createTextNodeFromTextContent(translatedChild);
962  }
963  sourceElement.removeChild(sourceChild);
964  const clone = sourceChild.cloneNode(false);
965  return shallowPopulateUsing(translatedChild, clone);
966}
967function createSanitizedElement(element) {
968  const clone = element.ownerDocument.createElement(element.localName);
969  return shallowPopulateUsing(element, clone);
970}
971function createTextNodeFromTextContent(element) {
972  return element.ownerDocument.createTextNode(element.textContent);
973}
974function isElementAllowed(element) {
975  const allowed = TEXT_LEVEL_ELEMENTS[element.namespaceURI];
976  return allowed && allowed.includes(element.localName);
977}
978function isAttrNameLocalizable(name, element, explicitlyAllowed = null) {
979  if (explicitlyAllowed && explicitlyAllowed.includes(name)) {
980    return true;
981  }
982  const allowed = LOCALIZABLE_ATTRIBUTES[element.namespaceURI];
983  if (!allowed) {
984    return false;
985  }
986  const attrName = name.toLowerCase();
987  const elemName = element.localName;
988  if (allowed.global.includes(attrName)) {
989    return true;
990  }
991  if (!allowed[elemName]) {
992    return false;
993  }
994  if (allowed[elemName].includes(attrName)) {
995    return true;
996  }
997  if (element.namespaceURI === "http://www.w3.org/1999/xhtml" && elemName === "input" && attrName === "value") {
998    const type = element.type.toLowerCase();
999    if (type === "submit" || type === "button" || type === "reset") {
1000      return true;
1001    }
1002  }
1003  return false;
1004}
1005function shallowPopulateUsing(fromElement, toElement) {
1006  toElement.textContent = fromElement.textContent;
1007  overlayAttributes(fromElement, toElement);
1008  return toElement;
1009}
1010;// CONCATENATED MODULE: ./node_modules/cached-iterable/src/cached_iterable.mjs
1011class CachedIterable extends Array {
1012  static from(iterable) {
1013    if (iterable instanceof this) {
1014      return iterable;
1015    }
1016    return new this(iterable);
1017  }
1018}
1019;// CONCATENATED MODULE: ./node_modules/cached-iterable/src/cached_sync_iterable.mjs
1020
1021class CachedSyncIterable extends CachedIterable {
1022  constructor(iterable) {
1023    super();
1024    if (Symbol.iterator in Object(iterable)) {
1025      this.iterator = iterable[Symbol.iterator]();
1026    } else {
1027      throw new TypeError("Argument must implement the iteration protocol.");
1028    }
1029  }
1030  [Symbol.iterator]() {
1031    const cached = this;
1032    let cur = 0;
1033    return {
1034      next() {
1035        if (cached.length <= cur) {
1036          cached.push(cached.iterator.next());
1037        }
1038        return cached[cur++];
1039      }
1040    };
1041  }
1042  touchNext(count = 1) {
1043    let idx = 0;
1044    while (idx++ < count) {
1045      const last = this[this.length - 1];
1046      if (last && last.done) {
1047        break;
1048      }
1049      this.push(this.iterator.next());
1050    }
1051    return this[this.length - 1];
1052  }
1053}
1054;// CONCATENATED MODULE: ./node_modules/cached-iterable/src/cached_async_iterable.mjs
1055
1056class CachedAsyncIterable extends CachedIterable {
1057  constructor(iterable) {
1058    super();
1059    if (Symbol.asyncIterator in Object(iterable)) {
1060      this.iterator = iterable[Symbol.asyncIterator]();
1061    } else if (Symbol.iterator in Object(iterable)) {
1062      this.iterator = iterable[Symbol.iterator]();
1063    } else {
1064      throw new TypeError("Argument must implement the iteration protocol.");
1065    }
1066  }

1067  [Symbol.asyncIterator]() {
1068    const cached = this;
1069    let cur = 0;
1070    return {
1071      async next() {
1072        if (cached.length <= cur) {
1073          cached.push(cached.iterator.next());
1074        }
1075        return cached[cur++];
1076      }
1077    };
1078  }
1079  async touchNext(count = 1) {
1080    let idx = 0;
1081    while (idx++ < count) {
1082      const last = this[this.length - 1];
1083      if (last && (await last).done) {
1084        break;
1085      }
1086      this.push(this.iterator.next());
1087    }
1088    return this[this.length - 1];
1089  }
1090}
1091;// CONCATENATED MODULE: ./node_modules/cached-iterable/src/index.mjs
1092
1093
1094;// CONCATENATED MODULE: ./node_modules/@fluent/dom/esm/localization.js
1095
1096class Localization {
1097  constructor(resourceIds = [], generateBundles) {
1098    this.resourceIds = resourceIds;
1099    this.generateBundles = generateBundles;
1100    this.onChange(true);
1101  }
1102  addResourceIds(resourceIds, eager = false) {
1103    this.resourceIds.push(...resourceIds);
1104    this.onChange(eager);
1105    return this.resourceIds.length;
1106  }
1107  removeResourceIds(resourceIds) {
1108    this.resourceIds = this.resourceIds.filter(r => !resourceIds.includes(r));
1109    this.onChange();
1110    return this.resourceIds.length;
1111  }
1112  async formatWithFallback(keys, method) {
1113    const translations = [];
1114    let hasAtLeastOneBundle = false;
1115    for await (const bundle of this.bundles) {
1116      hasAtLeastOneBundle = true;
1117      const missingIds = keysFromBundle(method, bundle, keys, translations);
1118      if (missingIds.size === 0) {
1119        break;
1120      }
1121      if (typeof console !== "undefined") {
1122        const locale = bundle.locales[0];
1123        const ids = Array.from(missingIds).join(", ");
1124        console.warn(`[fluent] Missing translations in ${locale}: ${ids}`);
1125      }
1126    }
1127    if (!hasAtLeastOneBundle && typeof console !== "undefined") {
1128      console.warn(`[fluent] Request for keys failed because no resource bundles got generated.
1129  keys: ${JSON.stringify(keys)}.
1130  resourceIds: ${JSON.stringify(this.resourceIds)}.`);
1131    }
1132    return translations;
1133  }
1134  formatMessages(keys) {
1135    return this.formatWithFallback(keys, messageFromBundle);
1136  }
1137  formatValues(keys) {
1138    return this.formatWithFallback(keys, valueFromBundle);
1139  }
1140  async formatValue(id, args) {
1141    const [val] = await this.formatValues([{
1142      id,
1143      args
1144    }]);
1145    return val;
1146  }
1147  handleEvent() {
1148    this.onChange();
1149  }
1150  onChange(eager = false) {
1151    this.bundles = CachedAsyncIterable.from(this.generateBundles(this.resourceIds));
1152    if (eager) {
1153      this.bundles.touchNext(2);
1154    }
1155  }
1156}
1157function valueFromBundle(bundle, errors, message, args) {
1158  if (message.value) {
1159    return bundle.formatPattern(message.value, args, errors);
1160  }
1161  return null;
1162}
1163function messageFromBundle(bundle, errors, message, args) {
1164  const formatted = {
1165    value: null,
1166    attributes: null
1167  };
1168  if (message.value) {
1169    formatted.value = bundle.formatPattern(message.value, args, errors);
1170  }
1171  let attrNames = Object.keys(message.attributes);
1172  if (attrNames.length > 0) {
1173    formatted.attributes = new Array(attrNames.length);
1174    for (let [i, name] of attrNames.entries()) {
1175      let value = bundle.formatPattern(message.attributes[name], args, errors);
1176      formatted.attributes[i] = {
1177        name,
1178        value
1179      };
1180    }
1181  }
1182  return formatted;
1183}
1184function keysFromBundle(method, bundle, keys, translations) {
1185  const messageErrors = [];
1186  const missingIds = new Set();
1187  keys.forEach(({
1188    id,
1189    args
1190  }, i) => {
1191    if (translations[i] !== undefined) {
1192      return;
1193    }
1194    let message = bundle.getMessage(id);
1195    if (message) {
1196      messageErrors.length = 0;
1197      translations[i] = method(bundle, messageErrors, message, args);
1198      if (messageErrors.length > 0 && typeof console !== "undefined") {
1199        const locale = bundle.locales[0];
1200        const errors = messageErrors.join(", ");
1201        console.warn(`[fluent][resolver] errors in ${locale}/${id}: ${errors}.`);
1202      }
1203    } else {
1204      missingIds.add(id);
1205    }
1206  });
1207  return missingIds;
1208}
1209;// CONCATENATED MODULE: ./node_modules/@fluent/dom/esm/dom_localization.js
1210
1211
1212const L10NID_ATTR_NAME = "data-l10n-id";
1213const L10NARGS_ATTR_NAME = "data-l10n-args";
1214const L10N_ELEMENT_QUERY = `[${L10NID_ATTR_NAME}]`;
1215class DOMLocalization extends Localization {
1216  constructor(resourceIds, generateBundles) {
1217    super(resourceIds, generateBundles);
1218    this.roots = new Set();
1219    this.pendingrAF = null;
1220    this.pendingElements = new Set();
1221    this.windowElement = null;
1222    this.mutationObserver = null;
1223    this.observerConfig = {
1224      attributes: true,
1225      characterData: false,
1226      childList: true,
1227      subtree: true,
1228      attributeFilter: [L10NID_ATTR_NAME, L10NARGS_ATTR_NAME]
1229    };
1230  }
1231  onChange(eager = false) {
1232    super.onChange(eager);
1233    if (this.roots) {
1234      this.translateRoots();
1235    }
1236  }
1237  setAttributes(element, id, args) {
1238    element.setAttribute(L10NID_ATTR_NAME, id);
1239    if (args) {
1240      element.setAttribute(L10NARGS_ATTR_NAME, JSON.stringify(args));
1241    } else {
1242      element.removeAttribute(L10NARGS_ATTR_NAME);
1243    }
1244    return element;
1245  }
1246  getAttributes(element) {
1247    return {
1248      id: element.getAttribute(L10NID_ATTR_NAME),
1249      args: JSON.parse(element.getAttribute(L10NARGS_ATTR_NAME) || null)
1250    };
1251  }
1252  connectRoot(newRoot) {
1253    for (const root of this.roots) {
1254      if (root === newRoot || root.contains(newRoot) || newRoot.contains(root)) {
1255        throw new Error("Cannot add a root that overlaps with existing root.");
1256      }
1257    }
1258    if (this.windowElement) {
1259      if (this.windowElement !== newRoot.ownerDocument.defaultView) {
1260        throw new Error(`Cannot connect a root:
1261          DOMLocalization already has a root from a different window.`);
1262      }
1263    } else {
1264      this.windowElement = newRoot.ownerDocument.defaultView;
1265      this.mutationObserver = new this.windowElement.MutationObserver(mutations => this.translateMutations(mutations));
1266    }
1267    this.roots.add(newRoot);
1268    this.mutationObserver.observe(newRoot, this.observerConfig);
1269  }
1270  disconnectRoot(root) {
1271    this.roots.delete(root);
1272    this.pauseObserving();
1273    if (this.roots.size === 0) {
1274      this.mutationObserver = null;
1275      this.windowElement = null;
1276      this.pendingrAF = null;
1277      this.pendingElements.clear();
1278      return true;
1279    }
1280    this.resumeObserving();
1281    return false;

1282  }
1283  translateRoots() {
1284    const roots = Array.from(this.roots);
1285    return Promise.all(roots.map(root => this.translateFragment(root)));
1286  }
1287  pauseObserving() {
1288    if (!this.mutationObserver) {
1289      return;
1290    }
1291    this.translateMutations(this.mutationObserver.takeRecords());
1292    this.mutationObserver.disconnect();
1293  }
1294  resumeObserving() {
1295    if (!this.mutationObserver) {
1296      return;
1297    }
1298    for (const root of this.roots) {
1299      this.mutationObserver.observe(root, this.observerConfig);
1300    }
1301  }
1302  translateMutations(mutations) {
1303    for (const mutation of mutations) {
1304      switch (mutation.type) {
1305        case "attributes":
1306          if (mutation.target.hasAttribute("data-l10n-id")) {
1307            this.pendingElements.add(mutation.target);
1308          }
1309          break;
1310        case "childList":
1311          for (const addedNode of mutation.addedNodes) {
1312            if (addedNode.nodeType === addedNode.ELEMENT_NODE) {
1313              if (addedNode.childElementCount) {
1314                for (const element of this.getTranslatables(addedNode)) {
1315                  this.pendingElements.add(element);
1316                }
1317              } else if (addedNode.hasAttribute(L10NID_ATTR_NAME)) {
1318                this.pendingElements.add(addedNode);
1319              }
1320            }
1321          }
1322          break;
1323      }
1324    }
1325    if (this.pendingElements.size > 0) {
1326      if (this.pendingrAF === null) {
1327        this.pendingrAF = this.windowElement.requestAnimationFrame(() => {
1328          this.translateElements(Array.from(this.pendingElements));
1329          this.pendingElements.clear();
1330          this.pendingrAF = null;
1331        });
1332      }
1333    }
1334  }
1335  translateFragment(frag) {
1336    return this.translateElements(this.getTranslatables(frag));
1337  }
1338  async translateElements(elements) {
1339    if (!elements.length) {
1340      return undefined;
1341    }
1342    const keys = elements.map(this.getKeysForElement);
1343    const translations = await this.formatMessages(keys);
1344    return this.applyTranslations(elements, translations);
1345  }
1346  applyTranslations(elements, translations) {
1347    this.pauseObserving();
1348    for (let i = 0; i < elements.length; i++) {
1349      if (translations[i] !== undefined) {
1350        translateElement(elements[i], translations[i]);
1351      }
1352    }
1353    this.resumeObserving();
1354  }
1355  getTranslatables(element) {
1356    const nodes = Array.from(element.querySelectorAll(L10N_ELEMENT_QUERY));
1357    if (typeof element.hasAttribute === "function" && element.hasAttribute(L10NID_ATTR_NAME)) {
1358      nodes.push(element);
1359    }
1360    return nodes;
1361  }
1362  getKeysForElement(element) {
1363    return {
1364      id: element.getAttribute(L10NID_ATTR_NAME),
1365      args: JSON.parse(element.getAttribute(L10NARGS_ATTR_NAME) || null)
1366    };
1367  }
1368}
1369;// CONCATENATED MODULE: ./node_modules/@fluent/dom/esm/index.js
1370
1371
1372
1373/***/ }),
1374
1375/***/ 259:
1376/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
1377
1378__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
1379/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1380/* harmony export */   AltTextManager: () => (/* binding */ AltTextManager)
1381/* harmony export */ });
1382/* harmony import */ var pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2603);
1383var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__]);
1384pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
1385
1386class AltTextManager {
1387  #boundUpdateUIState = this.#updateUIState.bind(this);
1388  #boundSetPosition = this.#setPosition.bind(this);
1389  #boundOnClick = this.#onClick.bind(this);
1390  #currentEditor = null;
1391  #cancelButton;
1392  #dialog;
1393  #eventBus;
1394  #hasUsedPointer = false;
1395  #optionDescription;
1396  #optionDecorative;
1397  #overlayManager;
1398  #saveButton;
1399  #textarea;
1400  #uiManager;
1401  #previousAltText = null;
1402  #svgElement = null;
1403  #rectElement = null;
1404  #container;
1405  #telemetryData = null;
1406  constructor({
1407    dialog,
1408    optionDescription,
1409    optionDecorative,
1410    textarea,

1411    cancelButton,
1412    saveButton
1413  }, container, overlayManager, eventBus) {
1414    this.#dialog = dialog;
1415    this.#optionDescription = optionDescription;
1416    this.#optionDecorative = optionDecorative;
1417    this.#textarea = textarea;
1418    this.#cancelButton = cancelButton;
1419    this.#saveButton = saveButton;
1420    this.#overlayManager = overlayManager;
1421    this.#eventBus = eventBus;
1422    this.#container = container;
1423    dialog.addEventListener("close", this.#close.bind(this));
1424    dialog.addEventListener("contextmenu", event => {
1425      if (event.target !== this.#textarea) {
1426        event.preventDefault();
1427      }
1428    });
1429    cancelButton.addEventListener("click", this.#finish.bind(this));
1430    saveButton.addEventListener("click", this.#save.bind(this));
1431    optionDescription.addEventListener("change", this.#boundUpdateUIState);
1432    optionDecorative.addEventListener("change", this.#boundUpdateUIState);
1433    this.#overlayManager.register(dialog);
1434  }
1435  get _elements() {
1436    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.shadow)(this, "_elements", [this.#optionDescription, this.#optionDecorative, this.#textarea, this.#saveButton, this.#cancelButton]);
1437  }
1438  #createSVGElement() {
1439    if (this.#svgElement) {
1440      return;
1441    }
1442    const svgFactory = new pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.DOMSVGFactory();
1443    const svg = this.#svgElement = svgFactory.createElement("svg");
1444    svg.setAttribute("width", "0");
1445    svg.setAttribute("height", "0");
1446    const defs = svgFactory.createElement("defs");
1447    svg.append(defs);
1448    const mask = svgFactory.createElement("mask");
1449    defs.append(mask);
1450    mask.setAttribute("id", "alttext-manager-mask");
1451    mask.setAttribute("maskContentUnits", "objectBoundingBox");
1452    let rect = svgFactory.createElement("rect");
1453    mask.append(rect);
1454    rect.setAttribute("fill", "white");
1455    rect.setAttribute("width", "1");
1456    rect.setAttribute("height", "1");
1457    rect.setAttribute("x", "0");
1458    rect.setAttribute("y", "0");
1459    rect = this.#rectElement = svgFactory.createElement("rect");
1460    mask.append(rect);
1461    rect.setAttribute("fill", "black");
1462    this.#dialog.append(svg);
1463  }
1464  async editAltText(uiManager, editor) {
1465    if (this.#currentEditor || !editor) {
1466      return;
1467    }
1468    this.#createSVGElement();
1469    this.#hasUsedPointer = false;
1470    for (const element of this._elements) {
1471      element.addEventListener("click", this.#boundOnClick);
1472    }
1473    const {
1474      altText,
1475      decorative
1476    } = editor.altTextData;
1477    if (decorative === true) {
1478      this.#optionDecorative.checked = true;
1479      this.#optionDescription.checked = false;
1480    } else {
1481      this.#optionDecorative.checked = false;
1482      this.#optionDescription.checked = true;
1483    }
1484    this.#previousAltText = this.#textarea.value = altText?.trim() || "";
1485    this.#updateUIState();
1486    this.#currentEditor = editor;
1487    this.#uiManager = uiManager;
1488    this.#uiManager.removeEditListeners();
1489    this.#eventBus._on("resize", this.#boundSetPosition);
1490    try {
1491      await this.#overlayManager.open(this.#dialog);
1492      this.#setPosition();
1493    } catch (ex) {
1494      this.#close();
1495      throw ex;
1496    }
1497  }
1498  #setPosition() {
1499    if (!this.#currentEditor) {
1500      return;
1501    }
1502    const dialog = this.#dialog;
1503    const {
1504      style
1505    } = dialog;
1506    const {
1507      x: containerX,
1508      y: containerY,
1509      width: containerW,
1510      height: containerH
1511    } = this.#container.getBoundingClientRect();
1512    const {
1513      innerWidth: windowW,
1514      innerHeight: windowH
1515    } = window;
1516    const {
1517      width: dialogW,
1518      height: dialogH
1519    } = dialog.getBoundingClientRect();
1520    const {
1521      x,
1522      y,
1523      width,
1524      height
1525    } = this.#currentEditor.getClientDimensions();
1526    const MARGIN = 10;
1527    const isLTR = this.#uiManager.direction === "ltr";
1528    const xs = Math.max(x, containerX);
1529    const xe = Math.min(x + width, containerX + containerW);
1530    const ys = Math.max(y, containerY);
1531    const ye = Math.min(y + height, containerY + containerH);
1532    this.#rectElement.setAttribute("width", `${(xe - xs) / windowW}`);
1533    this.#rectElement.setAttribute("height", `${(ye - ys) / windowH}`);
1534    this.#rectElement.setAttribute("x", `${xs / windowW}`);
1535    this.#rectElement.setAttribute("y", `${ys / windowH}`);
1536    let left = null;
1537    let top = Math.max(y, 0);
1538    top += Math.min(windowH - (top + dialogH), 0);
1539    if (isLTR) {
1540      if (x + width + MARGIN + dialogW < windowW) {
1541        left = x + width + MARGIN;
1542      } else if (x > dialogW + MARGIN) {
1543        left = x - dialogW - MARGIN;
1544      }
1545    } else if (x > dialogW + MARGIN) {
1546      left = x - dialogW - MARGIN;
1547    } else if (x + width + MARGIN + dialogW < windowW) {
1548      left = x + width + MARGIN;
1549    }
1550    if (left === null) {
1551      top = null;
1552      left = Math.max(x, 0);
1553      left += Math.min(windowW - (left + dialogW), 0);
1554      if (y > dialogH + MARGIN) {
1555        top = y - dialogH - MARGIN;
1556      } else if (y + height + MARGIN + dialogH < windowH) {
1557        top = y + height + MARGIN;
1558      }
1559    }
1560    if (top !== null) {
1561      dialog.classList.add("positioned");
1562      if (isLTR) {
1563        style.left = `${left}px`;
1564      } else {
1565        style.right = `${windowW - left - dialogW}px`;
1566      }
1567      style.top = `${top}px`;
1568    } else {
1569      dialog.classList.remove("positioned");
1570      style.left = "";
1571      style.top = "";
1572    }
1573  }
1574  #finish() {
1575    if (this.#overlayManager.active === this.#dialog) {
1576      this.#overlayManager.close(this.#dialog);
1577    }
1578  }
1579  #close() {
1580    this.#currentEditor._reportTelemetry(this.#telemetryData || {

1581      action: "alt_text_cancel",
1582      alt_text_keyboard: !this.#hasUsedPointer
1583    });
1584    this.#telemetryData = null;
1585    this.#removeOnClickListeners();
1586    this.#uiManager?.addEditListeners();
1587    this.#eventBus._off("resize", this.#boundSetPosition);
1588    this.#currentEditor.altTextFinish();
1589    this.#currentEditor = null;
1590    this.#uiManager = null;
1591  }
1592  #updateUIState() {
1593    this.#textarea.disabled = this.#optionDecorative.checked;
1594  }
1595  #save() {
1596    const altText = this.#textarea.value.trim();
1597    const decorative = this.#optionDecorative.checked;
1598    this.#currentEditor.altTextData = {
1599      altText,
1600      decorative
1601    };
1602    this.#telemetryData = {
1603      action: "alt_text_save",
1604      alt_text_description: !!altText,
1605      alt_text_edit: !!this.#previousAltText && this.#previousAltText !== altText,
1606      alt_text_decorative: decorative,
1607      alt_text_keyboard: !this.#hasUsedPointer
1608    };
1609    this.#finish();
1610  }
1611  #onClick(evt) {
1612    if (evt.detail === 0) {
1613      return;
1614    }
1615    this.#hasUsedPointer = true;
1616    this.#removeOnClickListeners();
1617  }
1618  #removeOnClickListeners() {
1619    for (const element of this._elements) {
1620      element.removeEventListener("click", this.#boundOnClick);
1621    }
1622  }
1623  destroy() {
1624    this.#uiManager = null;
1625    this.#finish();
1626    this.#svgElement?.remove();
1627    this.#svgElement = this.#rectElement = null;
1628  }
1629}
1630
1631__webpack_async_result__();
1632} catch(e) { __webpack_async_result__(e); } });
1633
1634/***/ }),
1635
1636/***/ 283:
1637/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
1638
1639__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
1640/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1641/* harmony export */   AnnotationEditorLayerBuilder: () => (/* binding */ AnnotationEditorLayerBuilder)
1642/* harmony export */ });
1643/* harmony import */ var pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2603);
1644/* harmony import */ var web_null_l10n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(410);
1645var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__, web_null_l10n__WEBPACK_IMPORTED_MODULE_1__]);
1646([pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__, web_null_l10n__WEBPACK_IMPORTED_MODULE_1__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);
1647
1648
1649class AnnotationEditorLayerBuilder {
1650  #annotationLayer = null;
1651  #drawLayer = null;
1652  #onAppend = null;
1653  #textLayer = null;
1654  #uiManager;
1655  constructor(options) {
1656    this.pdfPage = options.pdfPage;
1657    this.accessibilityManager = options.accessibilityManager;
1658    this.l10n = options.l10n;
1659    this.l10n ||= new web_null_l10n__WEBPACK_IMPORTED_MODULE_1__.GenericL10n();
1660    this.annotationEditorLayer = null;
1661    this.div = null;
1662    this._cancelled = false;
1663    this.#uiManager = options.uiManager;
1664    this.#annotationLayer = options.annotationLayer || null;
1665    this.#textLayer = options.textLayer || null;
1666    this.#drawLayer = options.drawLayer || null;
1667    this.#onAppend = options.onAppend || null;
1668  }
1669  async render(viewport, intent = "display") {
1670    if (intent !== "display") {
1671      return;
1672    }
1673    if (this._cancelled) {
1674      return;
1675    }
1676    const clonedViewport = viewport.clone({
1677      dontFlip: true
1678    });
1679    if (this.div) {
1680      this.annotationEditorLayer.update({
1681        viewport: clonedViewport
1682      });
1683      this.show();
1684      return;
1685    }
1686    const div = this.div = document.createElement("div");
1687    div.className = "annotationEditorLayer";
1688    div.hidden = true;
1689    div.dir = this.#uiManager.direction;
1690    this.#onAppend?.(div);
1691    this.annotationEditorLayer = new pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorLayer({
1692      uiManager: this.#uiManager,
1693      div,
1694      accessibilityManager: this.accessibilityManager,
1695      pageIndex: this.pdfPage.pageNumber - 1,
1696      l10n: this.l10n,
1697      viewport: clonedViewport,
1698      annotationLayer: this.#annotationLayer,
1699      textLayer: this.#textLayer,
1700      drawLayer: this.#drawLayer
1701    });
1702    const parameters = {
1703      viewport: clonedViewport,
1704      div,
1705      annotations: null,
1706      intent
1707    };
1708    this.annotationEditorLayer.render(parameters);
1709    this.show();
1710  }
1711  cancel() {
1712    this._cancelled = true;
1713    if (!this.div) {
1714      return;
1715    }
1716    this.annotationEditorLayer.destroy();
1717  }
1718  hide() {
1719    if (!this.div) {
1720      return;
1721    }
1722    this.div.hidden = true;
1723  }
1724  show() {
1725    if (!this.div || this.annotationEditorLayer.isInvisible) {
1726      return;
1727    }
1728    this.div.hidden = false;

1729  }
1730}
1731
1732__webpack_async_result__();
1733} catch(e) { __webpack_async_result__(e); } });
1734
1735/***/ }),
1736
1737/***/ 226:
1738/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
1739
1740__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
1741/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1742/* harmony export */   AnnotationEditorParams: () => (/* binding */ AnnotationEditorParams)
1743/* harmony export */ });
1744/* harmony import */ var pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2603);
1745var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__]);
1746pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
1747
1748class AnnotationEditorParams {
1749  constructor(options, eventBus) {
1750    this.eventBus = eventBus;
1751    this.#bindListeners(options);
1752  }
1753  #bindListeners({
1754    editorFreeTextFontSize,
1755    editorFreeTextColor,
1756    editorInkColor,
1757    editorInkThickness,
1758    editorInkOpacity,
1759    editorStampAddImage,
1760    editorFreeHighlightThickness,
1761    editorHighlightShowAll
1762  }) {
1763    const dispatchEvent = (typeStr, value) => {
1764      this.eventBus.dispatch("switchannotationeditorparams", {
1765        source: this,
1766        type: pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType[typeStr],
1767        value
1768      });
1769    };
1770    editorFreeTextFontSize.addEventListener("input", function () {
1771      dispatchEvent("FREETEXT_SIZE", this.valueAsNumber);
1772    });
1773    editorFreeTextColor.addEventListener("input", function () {
1774      dispatchEvent("FREETEXT_COLOR", this.value);
1775    });
1776    editorInkColor.addEventListener("input", function () {
1777      dispatchEvent("INK_COLOR", this.value);
1778    });
1779    editorInkThickness.addEventListener("input", function () {
1780      dispatchEvent("INK_THICKNESS", this.valueAsNumber);
1781    });
1782    editorInkOpacity.addEventListener("input", function () {
1783      dispatchEvent("INK_OPACITY", this.valueAsNumber);
1784    });
1785    editorStampAddImage.addEventListener("click", () => {
1786      dispatchEvent("CREATE");
1787    });
1788    editorFreeHighlightThickness.addEventListener("input", function () {
1789      dispatchEvent("HIGHLIGHT_THICKNESS", this.valueAsNumber);
1790    });
1791    editorHighlightShowAll.addEventListener("click", function () {
1792      const checked = this.getAttribute("aria-pressed") === "true";
1793      this.setAttribute("aria-pressed", !checked);
1794      dispatchEvent("HIGHLIGHT_SHOW_ALL", !checked);
1795    });
1796    this.eventBus._on("annotationeditorparamschanged", evt => {
1797      for (const [type, value] of evt.details) {
1798        switch (type) {
1799          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.FREETEXT_SIZE:
1800            editorFreeTextFontSize.value = value;
1801            break;
1802          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.FREETEXT_COLOR:
1803            editorFreeTextColor.value = value;
1804            break;
1805          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.INK_COLOR:
1806            editorInkColor.value = value;
1807            break;
1808          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.INK_THICKNESS:
1809            editorInkThickness.value = value;
1810            break;
1811          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.INK_OPACITY:
1812            editorInkOpacity.value = value;
1813            break;
1814          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.HIGHLIGHT_THICKNESS:
1815            editorFreeHighlightThickness.value = value;
1816            break;
1817          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.HIGHLIGHT_FREE:
1818            editorFreeHighlightThickness.disabled = !value;
1819            break;
1820          case pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationEditorParamsType.HIGHLIGHT_SHOW_ALL:
1821            editorHighlightShowAll.setAttribute("aria-pressed", value);
1822            break;
1823        }
1824      }
1825    });
1826  }
1827}
1828
1829__webpack_async_result__();
1830} catch(e) { __webpack_async_result__(e); } });
1831
1832/***/ }),
1833
1834/***/ 2707:
1835/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
1836
1837__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
1838/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1839/* harmony export */   AnnotationLayerBuilder: () => (/* binding */ AnnotationLayerBuilder)
1840/* harmony export */ });
1841/* harmony import */ var pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2603);
1842/* harmony import */ var _ui_utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7256);
1843var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__]);
1844pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
1845
1846
1847class AnnotationLayerBuilder {
1848  #onAppend = null;
1849  #onPresentationModeChanged = null;
1850  constructor({
1851    pdfPage,
1852    linkService,
1853    downloadManager,
1854    annotationStorage = null,
1855    imageResourcesPath = "",
1856    renderForms = true,
1857    enableScripting = false,

1858    hasJSActionsPromise = null,
1859    fieldObjectsPromise = null,
1860    annotationCanvasMap = null,
1861    accessibilityManager = null,
1862    onAppend = null
1863  }) {
1864    this.pdfPage = pdfPage;
1865    this.linkService = linkService;
1866    this.downloadManager = downloadManager;
1867    this.imageResourcesPath = imageResourcesPath;
1868    this.renderForms = renderForms;
1869    this.annotationStorage = annotationStorage;
1870    this.enableScripting = enableScripting;
1871    this._hasJSActionsPromise = hasJSActionsPromise || Promise.resolve(false);
1872    this._fieldObjectsPromise = fieldObjectsPromise || Promise.resolve(null);
1873    this._annotationCanvasMap = annotationCanvasMap;
1874    this._accessibilityManager = accessibilityManager;
1875    this.#onAppend = onAppend;
1876    this.annotationLayer = null;
1877    this.div = null;
1878    this._cancelled = false;
1879    this._eventBus = linkService.eventBus;
1880  }
1881  async render(viewport, intent = "display") {
1882    if (this.div) {
1883      if (this._cancelled || !this.annotationLayer) {
1884        return;
1885      }
1886      this.annotationLayer.update({
1887        viewport: viewport.clone({
1888          dontFlip: true
1889        })
1890      });
1891      return;
1892    }
1893    const [annotations, hasJSActions, fieldObjects] = await Promise.all([this.pdfPage.getAnnotations({
1894      intent
1895    }), this._hasJSActionsPromise, this._fieldObjectsPromise]);
1896    if (this._cancelled) {
1897      return;
1898    }
1899    const div = this.div = document.createElement("div");
1900    div.className = "annotationLayer";
1901    this.#onAppend?.(div);
1902    if (annotations.length === 0) {
1903      this.hide();
1904      return;
1905    }
1906    this.annotationLayer = new pdfjs_lib__WEBPACK_IMPORTED_MODULE_0__.AnnotationLayer({
1907      div,
1908      accessibilityManager: this._accessibilityManager,
1909      annotationCanvasMap: this._annotationCanvasMap,
1910      page: this.pdfPage,
1911      viewport: viewport.clone({
1912        dontFlip: true
1913      })
1914    });
1915    await this.annotationLayer.render({
1916      annotations,
1917      imageResourcesPath: this.imageResourcesPath,
1918      renderForms: this.renderForms,
1919      linkService: this.linkService,
1920      downloadManager: this.downloadManager,
1921      annotationStorage: this.annotationStorage,
1922      enableScripting: this.enableScripting,
1923      hasJSActions,
1924      fieldObjects
1925    });
1926    if (this.linkService.isInPresentationMode) {
1927      this.#updatePresentationModeState(_ui_utils_js__WEBPACK_IMPORTED_MODULE_1__.PresentationModeState.FULLSCREEN);
1928    }
1929    if (!this.#onPresentationModeChanged) {
1930      this.#onPresentationModeChanged = evt => {
1931        this.#updatePresentationModeState(evt.state);
1932      };
1933      this._eventBus?._on("presentationmodechanged", this.#onPresentationModeChanged);
1934    }
1935  }
1936  cancel() {
1937    this._cancelled = true;
1938    if (this.#onPresentationModeChanged) {
1939      this._eventBus?._off("presentationmodechanged", this.#onPresentationModeChanged);
1940      this.#onPresentationModeChanged = null;
1941    }
1942  }
1943  hide() {
1944    if (!this.div) {
1945      return;
1946    }
1947    this.div.hidden = true;
1948  }
1949  #updatePresentationModeState(state) {
1950    if (!this.div) {
1951      return;
1952    }
1953    let disableFormElements = false;
1954    switch (state) {
1955      case _ui_utils_js__WEBPACK_IMPORTED_MODULE_1__.PresentationModeState.FULLSCREEN:
1956        disableFormElements = true;
1957        break;
1958      case _ui_utils_js__WEBPACK_IMPORTED_MODULE_1__.PresentationModeState.NORMAL:
1959        break;
1960      default:
1961        return;
1962    }
1963    for (const section of this.div.childNodes) {
1964      if (section.hasAttribute("data-internal-link")) {
1965        continue;
1966      }
1967      section.inert = disableFormElements;
1968    }
1969  }
1970}
1971
1972__webpack_async_result__();
1973} catch(e) { __webpack_async_result__(e); } });
1974
1975/***/ }),
1976
1977/***/ 1621:
1978/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
1979
1980__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
1981/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1982/* harmony export */   PDFViewerApplication: () => (/* binding */ PDFViewerApplication)
1983/* harmony export */ });
1984/* harmony import */ var _ui_utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7256);
1985/* harmony import */ var pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2603);
1986/* harmony import */ var _app_options_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9840);
1987/* harmony import */ var _event_utils_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5656);
1988/* harmony import */ var web_external_services__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6750);
1989/* harmony import */ var _pdf_link_service_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(787);
1990/* harmony import */ var web_alt_text_manager__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(259);
1991/* harmony import */ var web_annotation_editor_params__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(226);
1992/* harmony import */ var _caret_browsing_js__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(3973);
1993/* harmony import */ var web_download_manager__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(1544);
1994/* harmony import */ var _overlay_manager_js__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(6174);
1995/* harmony import */ var _password_prompt_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2690);
1996/* harmony import */ var web_pdf_attachment_viewer__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(9251);
1997/* harmony import */ var web_pdf_cursor_tools__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(5993);
1998/* harmony import */ var web_pdf_document_properties__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(164);
1999/* harmony import */ var web_pdf_find_bar__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(2226);
2000/* harmony import */ var _pdf_find_controller_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(9814);
2001/* harmony import */ var _pdf_history_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(8543);
2002/* harmony import */ var web_pdf_layer_viewer__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(4275);
2003/* harmony import */ var web_pdf_outline_viewer__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(5514);
2004/* harmony import */ var web_pdf_presentation_mode__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(8917);
2005/* harmony import */ var web_print_service__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(1144);
2006/* harmony import */ var _pdf_rendering_queue_js__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(6615);
2007/* harmony import */ var _pdf_scripting_manager_js__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(5942);
2008/* harmony import */ var web_pdf_sidebar__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(2275);
2009/* harmony import */ var web_pdf_thumbnail_viewer__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(8280);
2010/* harmony import */ var _pdf_viewer_js__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(6285);
2011/* harmony import */ var web_secondary_toolbar__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(1900);
2012/* harmony import */ var web_toolbar__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(6297);
2013/* harmony import */ var _view_history_js__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(9226);
2014var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__, web_external_services__WEBPACK_IMPORTED_MODULE_4__, web_alt_text_manager__WEBPACK_IMPORTED_MODULE_6__, web_annotation_editor_params__WEBPACK_IMPORTED_MODULE_7__, web_download_manager__WEBPACK_IMPORTED_MODULE_8__, _password_prompt_js__WEBPACK_IMPORTED_MODULE_9__, web_pdf_attachment_viewer__WEBPACK_IMPORTED_MODULE_10__, web_pdf_cursor_tools__WEBPACK_IMPORTED_MODULE_11__, web_pdf_document_properties__WEBPACK_IMPORTED_MODULE_12__, web_pdf_presentation_mode__WEBPACK_IMPORTED_MODULE_18__, web_print_service__WEBPACK_IMPORTED_MODULE_19__, _pdf_rendering_queue_js__WEBPACK_IMPORTED_MODULE_20__, _pdf_scripting_manager_js__WEBPACK_IMPORTED_MODULE_21__, web_pdf_thumbnail_viewer__WEBPACK_IMPORTED_MODULE_23__, _pdf_viewer_js__WEBPACK_IMPORTED_MODULE_24__, web_secondary_toolbar__WEBPACK_IMPORTED_MODULE_25__, web_toolbar__WEBPACK_IMPORTED_MODULE_26__]);
2015([pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__, web_external_services__WEBPACK_IMPORTED_MODULE_4__, web_alt_text_manager__WEBPACK_IMPORTED_MODULE_6__, web_annotation_editor_params__WEBPACK_IMPORTED_MODULE_7__, web_download_manager__WEBPACK_IMPORTED_MODULE_8__, _password_prompt_js__WEBPACK_IMPORTED_MODULE_9__, web_pdf_attachment_viewer__WEBPACK_IMPORTED_MODULE_10__, web_pdf_cursor_tools__WEBPACK_IMPORTED_MODULE_11__, web_pdf_document_properties__WEBPACK_IMPORTED_MODULE_12__, web_pdf_presentation_mode__WEBPACK_IMPORTED_MODULE_18__, web_print_service__WEBPACK_IMPORTED_MODULE_19__, _pdf_rendering_queue_js__WEBPACK_IMPORTED_MODULE_20__, _pdf_scripting_manager_js__WEBPACK_IMPORTED_MODULE_21__, web_pdf_thumbnail_viewer__WEBPACK_IMPORTED_MODULE_23__, _pdf_viewer_js__WEBPACK_IMPORTED_MODULE_24__, web_secondary_toolbar__WEBPACK_IMPORTED_MODULE_25__, web_toolbar__WEBPACK_IMPORTED_MODULE_26__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047const FORCE_PAGES_LOADED_TIMEOUT = 10000;
2048const WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
2049const ViewOnLoad = {
2050  UNKNOWN: -1,
2051  PREVIOUS: 0,
2052  INITIAL: 1
2053};
2054const PDFViewerApplication = {
2055  initialBookmark: document.location.hash.substring(1),
2056  _initializedCapability: {
2057    ...Promise.withResolvers(),
2058    settled: false
2059  },
2060  appConfig: null,
2061  pdfDocument: null,
2062  pdfLoadingTask: null,
2063  printService: null,
2064  pdfViewer: null,

2065  pdfThumbnailViewer: null,
2066  pdfRenderingQueue: null,
2067  pdfPresentationMode: null,
2068  pdfDocumentProperties: null,
2069  pdfLinkService: null,
2070  pdfHistory: null,
2071  pdfSidebar: null,
2072  pdfOutlineViewer: null,
2073  pdfAttachmentViewer: null,
2074  pdfLayerViewer: null,
2075  pdfCursorTools: null,
2076  pdfScriptingManager: null,
2077  store: null,
2078  downloadManager: null,
2079  overlayManager: null,
2080  preferences: null,
2081  toolbar: null,
2082  secondaryToolbar: null,
2083  eventBus: null,
2084  l10n: null,
2085  annotationEditorParams: null,
2086  isInitialViewSet: false,
2087  downloadComplete: false,
2088  isViewerEmbedded: window.parent !== window,
2089  url: "",
2090  baseUrl: "",
2091  _downloadUrl: "",
2092  _boundEvents: Object.create(null),
2093  documentInfo: null,
2094  metadata: null,
2095  _contentDispositionFilename: null,
2096  _contentLength: null,
2097  _saveInProgress: false,
2098  _wheelUnusedTicks: 0,
2099  _wheelUnusedFactor: 1,
2100  _touchUnusedTicks: 0,
2101  _touchUnusedFactor: 1,
2102  _PDFBug: null,
2103  _hasAnnotationEditors: false,
2104  _title: document.title,
2105  _printAnnotationStoragePromise: null,
2106  _touchInfo: null,
2107  _isCtrlKeyDown: false,
2108  _nimbusDataPromise: null,
2109  _caretBrowsing: null,
2110  _isScrolling: false,
2111  _lastScrollTop: 0,
2112  _lastScrollLeft: 0,

2113  async initialize(appConfig) {
2114    let l10nPromise;
2115    this.appConfig = appConfig;
2116    try {
2117      await this.preferences.initializedPromise;
2118    } catch (ex) {
2119      console.error(`initialize: "${ex.message}".`);
2120    }
2121    if (_app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("pdfBugEnabled")) {
2122      await this._parseHashParams();
2123    }
2124    let mode;
2125    switch (_app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("viewerCssTheme")) {
2126      case 1:
2127        mode = "is-light";
2128        break;
2129      case 2:
2130        mode = "is-dark";
2131        break;
2132    }
2133    if (mode) {
2134      document.documentElement.classList.add(mode);
2135    }
2136    l10nPromise = this.externalServices.createL10n();
2137    this.l10n = await l10nPromise;
2138    document.getElementsByTagName("html")[0].dir = this.l10n.getDirection();
2139    this.l10n.translate(appConfig.appContainer || document.documentElement);
2140    if (this.isViewerEmbedded && _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("externalLinkTarget") === _pdf_link_service_js__WEBPACK_IMPORTED_MODULE_5__.LinkTarget.NONE) {
2141      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("externalLinkTarget", _pdf_link_service_js__WEBPACK_IMPORTED_MODULE_5__.LinkTarget.TOP);
2142    }
2143    await this._initializeViewerComponents();
2144    this.bindEvents();
2145    this.bindWindowEvents();
2146    this._initializedCapability.settled = true;
2147    this._initializedCapability.resolve();
2148  },
2149  async _parseHashParams() {
2150    const hash = document.location.hash.substring(1);
2151    if (!hash) {
2152      return;
2153    }
2154    const {
2155        mainContainer,
2156        viewerContainer
2157      } = this.appConfig,
2158      params = (0,_ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.parseQueryString)(hash);
2159    if (params.get("disableworker") === "true") {
2160      try {
2161        await loadFakeWorker();
2162      } catch (ex) {
2163        console.error(`_parseHashParams: "${ex.message}".`);
2164      }
2165    }
2166    if (params.has("disablerange")) {
2167      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableRange", params.get("disablerange") === "true");
2168    }
2169    if (params.has("disablestream")) {
2170      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableStream", params.get("disablestream") === "true");
2171    }
2172    if (params.has("disableautofetch")) {
2173      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableAutoFetch", params.get("disableautofetch") === "true");
2174    }
2175    if (params.has("disablefontface")) {
2176      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableFontFace", params.get("disablefontface") === "true");
2177    }
2178    if (params.has("disablehistory")) {
2179      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableHistory", params.get("disablehistory") === "true");
2180    }
2181    if (params.has("verbosity")) {
2182      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("verbosity", params.get("verbosity") | 0);
2183    }
2184    if (params.has("textlayer")) {
2185      switch (params.get("textlayer")) {
2186        case "off":
2187          _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("textLayerMode", _ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.TextLayerMode.DISABLE);
2188          break;
2189        case "visible":
2190        case "shadow":
2191        case "hover":
2192          viewerContainer.classList.add(`textLayer-${params.get("textlayer")}`);
2193          try {
2194            await loadPDFBug(this);
2195            this._PDFBug.loadCSS();
2196          } catch (ex) {
2197            console.error(`_parseHashParams: "${ex.message}".`);
2198          }
2199          break;
2200      }
2201    }
2202    if (params.has("pdfbug")) {
2203      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("pdfBug", true);
2204      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("fontExtraProperties", true);
2205      const enabled = params.get("pdfbug").split(",");
2206      try {
2207        await loadPDFBug(this);
2208        this._PDFBug.init(mainContainer, enabled);
2209      } catch (ex) {
2210        console.error(`_parseHashParams: "${ex.message}".`);
2211      }
2212    }
2213    if (params.has("locale")) {
2214      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("locale", params.get("locale"));
2215    }
2216  },
2217  async _initializeViewerComponents() {
2218    const {
2219      appConfig,
2220      externalServices,
2221      l10n
2222    } = this;
2223    const eventBus = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("isInAutomation") ? new _event_utils_js__WEBPACK_IMPORTED_MODULE_3__.AutomationEventBus() : new _event_utils_js__WEBPACK_IMPORTED_MODULE_3__.EventBus();
2224    this.eventBus = eventBus;
2225    this.overlayManager = new _overlay_manager_js__WEBPACK_IMPORTED_MODULE_27__.OverlayManager();
2226    const pdfRenderingQueue = new _pdf_rendering_queue_js__WEBPACK_IMPORTED_MODULE_20__.PDFRenderingQueue();
2227    pdfRenderingQueue.onIdle = this._cleanup.bind(this);
2228    this.pdfRenderingQueue = pdfRenderingQueue;
2229    const pdfLinkService = new _pdf_link_service_js__WEBPACK_IMPORTED_MODULE_5__.PDFLinkService({
2230      eventBus,
2231      externalLinkTarget: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("externalLinkTarget"),
2232      externalLinkRel: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("externalLinkRel"),
2233      ignoreDestinationZoom: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("ignoreDestinationZoom")
2234    });
2235    this.pdfLinkService = pdfLinkService;
2236    const downloadManager = this.downloadManager = new web_download_manager__WEBPACK_IMPORTED_MODULE_8__.DownloadManager();
2237    const findController = new _pdf_find_controller_js__WEBPACK_IMPORTED_MODULE_14__.PDFFindController({
2238      linkService: pdfLinkService,
2239      eventBus,
2240      updateMatchesCountOnProgress: true
2241    });
2242    this.findController = findController;
2243    const pdfScriptingManager = new _pdf_scripting_manager_js__WEBPACK_IMPORTED_MODULE_21__.PDFScriptingManager({
2244      eventBus,
2245      externalServices,
2246      docProperties: this._scriptingDocProperties.bind(this)
2247    });
2248    this.pdfScriptingManager = pdfScriptingManager;
2249    const container = appConfig.mainContainer,
2250      viewer = appConfig.viewerContainer;
2251    const annotationEditorMode = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("annotationEditorMode");
2252    const isOffscreenCanvasSupported = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("isOffscreenCanvasSupported") && pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.FeatureTest.isOffscreenCanvasSupported;
2253    const pageColors = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("forcePageColors") || window.matchMedia("(forced-colors: active)").matches ? {
2254      background: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("pageColorsBackgroun

2254d"),
2255      foreground: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("pageColorsForeground")
2256    } : null;
2257    const altTextManager = appConfig.altTextDialog ? new web_alt_text_manager__WEBPACK_IMPORTED_MODULE_6__.AltTextManager(appConfig.altTextDialog, container, this.overlayManager, eventBus) : null;
2258    const pdfViewer = new _pdf_viewer_js__WEBPACK_IMPORTED_MODULE_24__.PDFViewer({
2259      container,
2260      viewer,
2261      eventBus,
2262      renderingQueue: pdfRenderingQueue,
2263      linkService: pdfLinkService,
2264      downloadManager,
2265      altTextManager,
2266      findController,
2267      scriptingManager: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enableScripting") && pdfScriptingManager,
2268      l10n,
2269      textLayerMode: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("textLayerMode"),
2270      annotationMode: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("annotationMode"),
2271      annotationEditorMode,
2272      annotationEditorHighlightColors: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("highlightEditorColors"),
2273      enableHighlightFloatingButton: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enableHighlightFloatingButton"),
2274      imageResourcesPath: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("imageResourcesPath"),
2275      enablePrintAutoRotate: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enablePrintAutoRotate"),
2276      maxCanvasPixels: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("maxCanvasPixels"),
2277      enablePermissions: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enablePermissions"),
2278      pageColors,
2279      mlManager: this.mlManager
2280    });
2281    this.pdfViewer = pdfViewer;
2282    pdfRenderingQueue.setViewer(pdfViewer);
2283    pdfLinkService.setViewer(pdfViewer);
2284    pdfScriptingManager.setViewer(pdfViewer);
2285    if (appConfig.sidebar?.thumbnailView) {
2286      this.pdfThumbnailViewer = new web_pdf_thumbnail_viewer__WEBPACK_IMPORTED_MODULE_23__.PDFThumbnailViewer({
2287        container: appConfig.sidebar.thumbnailView,
2288        eventBus,
2289        renderingQueue: pdfRenderingQueue,
2290        linkService: pdfLinkService,
2291        pageColors
2292      });
2293      pdfRenderingQueue.setThumbnailViewer(this.pdfThumbnailViewer);
2294    }
2295    if (!this.isViewerEmbedded && !_app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("disableHistory")) {
2296      this.pdfHistory = new _pdf_history_js__WEBPACK_IMPORTED_MODULE_15__.PDFHistory({
2297        linkService: pdfLinkService,
2298        eventBus
2299      });
2300      pdfLinkService.setHistory(this.pdfHistory);
2301    }
2302    if (!this.supportsIntegratedFind && appConfig.findBar) {
2303      this.findBar = new web_pdf_find_bar__WEBPACK_IMPORTED_MODULE_13__.PDFFindBar(appConfig.findBar, eventBus);
2304    }
2305    if (appConfig.annotationEditorParams) {
2306      if (annotationEditorMode !== pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.AnnotationEditorType.DISABLE) {
2307        if (_app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enableStampEditor") && isOffscreenCanvasSupported) {
2308          appConfig.toolbar?.editorStampButton?.classList.remove("hidden");
2309        }
2310        const editorHighlightButton = appConfig.toolbar?.editorHighlightButton;
2311        if (editorHighlightButton && _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enableHighlightEditor")) {
2312          editorHighlightButton.hidden = false;
2313        }
2314        this.annotationEditorParams = new web_annotation_editor_params__WEBPACK_IMPORTED_MODULE_7__.AnnotationEditorParams(appConfig.annotationEditorParams, eventBus);
2315      } else {
2316        for (const id of ["editorModeButtons", "editorModeSeparator"]) {
2317          document.getElementById(id)?.classList.add("hidden");
2318        }
2319      }
2320    }
2321    if (appConfig.documentProperties) {
2322      this.pdfDocumentProperties = new web_pdf_document_properties__WEBPACK_IMPORTED_MODULE_12__.PDFDocumentProperties(appConfig.documentProperties, this.overlayManager, eventBus, l10n, () => this._docFilename);
2323    }
2324    if (appConfig.secondaryToolbar?.cursorHandToolButton) {
2325      this.pdfCursorTools = new web_pdf_cursor_tools__WEBPACK_IMPORTED_MODULE_11__.PDFCursorTools({
2326        container,
2327        eventBus,
2328        cursorToolOnLoad: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("cursorToolOnLoad")
2329      });
2330    }
2331    if (appConfig.toolbar) {
2332      this.toolbar = new web_toolbar__WEBPACK_IMPORTED_MODULE_26__.Toolbar(appConfig.toolbar, eventBus);
2333    }
2334    if (appConfig.secondaryToolbar) {
2335      this.secondaryToolbar = new web_secondary_toolbar__WEBPACK_IMPORTED_MODULE_25__.SecondaryToolbar(appConfig.secondaryToolbar, eventBus);
2336    }
2337    if (this.supportsFullscreen && appConfig.secondaryToolbar?.presentationModeButton) {
2338      this.pdfPresentationMode = new web_pdf_presentation_mode__WEBPACK_IMPORTED_MODULE_18__.PDFPresentationMode({
2339        container,
2340        pdfViewer,
2341        eventBus
2342      });
2343    }
2344    if (appConfig.passwordOverlay) {
2345      this.passwordPrompt = new _password_prompt_js__WEBPACK_IMPORTED_MODULE_9__.PasswordPrompt(appConfig.passwordOverlay, this.overlayManager, this.isViewerEmbedded);
2346    }
2347    if (appConfig.sidebar?.outlineView) {
2348      this.pdfOutlineViewer = new web_pdf_outline_viewer__WEBPACK_IMPORTED_MODULE_17__.PDFOutlineViewer({
2349        container: appConfig.sidebar.outlineView,
2350        eventBus,
2351        l10n,
2352        linkService: pdfLinkService,
2353        downloadManager
2354      });
2355    }
2356    if (appConfig.sidebar?.attachmentsView) {
2357      this.pdfAttachmentViewer = new web_pdf_attachment_viewer__WEBPACK_IMPORTED_MODULE_10__.PDFAttachmentViewer({
2358        container: appConfig.sidebar.attachmentsView,
2359        eventBus,
2360        l10n,
2361        downloadManager
2362      });
2363    }
2364    if (appConfig.sidebar?.layersView) {
2365      this.pdfLayerViewer = new web_pdf_layer_viewer__WEBPACK_IMPORTED_MODULE_16__.PDFLayerViewer({
2366        container: appConfig.sidebar.layersView,
2367        eventBus,
2368        l10n
2369      });
2370    }
2371    if (appConfig.sidebar) {
2372      this.pdfSidebar = new web_pdf_sidebar__WEBPACK_IMPORTED_MODULE_22__.PDFSidebar({
2373        elements: appConfig.sidebar,
2374        eventBus,
2375        l10n
2376      });
2377      this.pdfSidebar.onToggled = this.forceRendering.bind(this);
2378      this.pdfSidebar.onUpdateThumbnails = () => {
2379        for (const pageView of pdfViewer.getCachedPageViews()) {
2380          if (pageView.renderingState === _ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.RenderingStates.FINISHED) {

2381            this.pdfThumbnailViewer.getThumbnail(pageView.id - 1)?.setImage(pageView);
2382          }
2383        }
2384        this.pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
2385      };
2386    }
2387  },
2388  async run(config) {
2389    this.preferences = new web_external_services__WEBPACK_IMPORTED_MODULE_4__.Preferences();
2390    await this.initialize(config);
2391    const {
2392      appConfig,
2393      eventBus
2394    } = this;
2395    let file;
2396    const queryString = document.location.search.substring(1);
2397    const params = (0,_ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.parseQueryString)(queryString);
2398    file = params.get("file") ?? _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("defaultUrl");
2399    validateFileURL(file);
2400    const fileInput = this._openFileInput = document.createElement("input");
2401    fileInput.id = "fileInput";
2402    fileInput.hidden = true;
2403    fileInput.type = "file";
2404    fileInput.value = null;
2405    document.body.append(fileInput);
2406    fileInput.addEventListener("change", function (evt) {
2407      const {
2408        files
2409      } = evt.target;
2410      if (!files || files.length === 0) {
2411        return;
2412      }
2413      eventBus.dispatch("fileinputchange", {
2414        source: this,
2415        fileInput: evt.target
2416      });
2417    });
2418    appConfig.mainContainer.addEventListener("dragover", function (evt) {
2419      evt.preventDefault();
2420      evt.dataTransfer.dropEffect = evt.dataTransfer.effectAllowed === "copy" ? "copy" : "move";
2421    });
2422    appConfig.mainContainer.addEventListener("drop", function (evt) {
2423      evt.preventDefault();
2424      const {
2425        files
2426      } = evt.dataTransfer;
2427      if (!files || files.length === 0) {
2428        return;
2429      }
2430      eventBus.dispatch("fileinputchange", {
2431        source: this,
2432        fileInput: evt.dataTransfer
2433      });
2434    });
2435    if (!_app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsDocumentFonts")) {
2436      _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.set("disableFontFace", true);
2437      this.l10n.get("pdfjs-web-fonts-disabled").then(msg => {
2438        console.warn(msg);
2439      });
2440    }
2441    if (!this.supportsPrinting) {
2442      appConfig.toolbar?.print?.classList.add("hidden");
2443      appConfig.secondaryToolbar?.printButton.classList.add("hidden");
2444    }
2445    if (!this.supportsFullscreen) {
2446      appConfig.secondaryToolbar?.presentationModeButton.classList.add("hidden");
2447    }
2448    if (this.supportsIntegratedFind) {
2449      appConfig.toolbar?.viewFind?.classList.add("hidden");
2450    }
2451    if (file) {
2452      this.open({
2453        url: file
2454      });
2455    } else {
2456      this._hideViewBookmark();
2457    }
2458  },
2459  get externalServices() {
2460    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "externalServices", new web_external_services__WEBPACK_IMPORTED_MODULE_4__.ExternalServices());
2461  },
2462  get mlManager() {
2463    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "mlManager", _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("enableML") === true ? new web_external_services__WEBPACK_IMPORTED_MODULE_4__.MLManager() : null);
2464  },
2465  get initialized() {
2466    return this._initializedCapability.settled;
2467  },
2468  get initializedPromise() {
2469    return this._initializedCapability.promise;
2470  },
2471  zoomIn(steps, scaleFactor) {
2472    if (this.pdfViewer.isInPresentationMode) {
2473      return;
2474    }
2475    this.pdfViewer.increaseScale({
2476      drawingDelay: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("defaultZoomDelay"),
2477      steps,
2478      scaleFactor
2479    });
2480  },
2481  zoomOut(steps, scaleFactor) {
2482    if (this.pdfViewer.isInPresentationMode) {
2483      return;
2484    }
2485    this.pdfViewer.decreaseScale({
2486      drawingDelay: _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("defaultZoomDelay"),
2487      steps,
2488      scaleFactor
2489    });
2490  },
2491  zoomReset() {
2492    if (this.pdfViewer.isInPresentationMode) {
2493      return;
2494    }
2495    this.pdfViewer.currentScaleValue = _ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.DEFAULT_SCALE_VALUE;
2496  },
2497  get pagesCount() {
2498    return this.pdfDocument ? this.pdfDocument.numPages : 0;
2499  },
2500  get page() {
2501    return this.pdfViewer.currentPageNumber;
2502  },
2503  set page(val) {
2504    this.pdfViewer.currentPageNumber = val;
2505  },
2506  get supportsPrinting() {
2507    return web_print_service__WEBPACK_IMPORTED_MODULE_19__.PDFPrintServiceFactory.supportsPrinting;
2508  },
2509  get supportsFullscreen() {
2510    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "supportsFullscreen", document.fullscreenEnabled);
2511  },
2512  get supportsPinchToZoom() {
2513    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "supportsPinchToZoom", _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsPinchToZoom"));
2514  },
2515  get supportsIntegratedFind() {
2516    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "supportsIntegratedFind", _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsIntegratedFind"));
2517  },
2518  get loadingBar() {
2519    const barElement = document.getElementById("loadingBar");
2520    const bar = barElement ? new _ui_utils_js__WEBPACK_IMPORTED_MODULE_0__.ProgressBar(barElement) : null;
2521    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "loadingBar", bar);
2522  },

2523  get supportsMouseWheelZoomCtrlKey() {
2524    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "supportsMouseWheelZoomCtrlKey", _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsMouseWheelZoomCtrlKey"));
2525  },
2526  get supportsMouseWheelZoomMetaKey() {
2527    return (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.shadow)(this, "supportsMouseWheelZoomMetaKey", _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsMouseWheelZoomMetaKey"));
2528  },
2529  get supportsCaretBrowsingMode() {
2530    return _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("supportsCaretBrowsingMode");
2531  },
2532  moveCaret(isUp, select) {
2533    this._caretBrowsing ||= new _caret_browsing_js__WEBPACK_IMPORTED_MODULE_28__.CaretBrowsingMode(this.appConfig.mainContainer, this.appConfig.viewerContainer, this.appConfig.toolbar?.container);
2534    this._caretBrowsing.moveCaret(isUp, select);
2535  },
2536  setTitleUsingUrl(url = "", downloadUrl = null) {
2537    this.url = url;
2538    this.baseUrl = url.split("#", 1)[0];
2539    if (downloadUrl) {
2540      this._downloadUrl = downloadUrl === url ? this.baseUrl : downloadUrl.split("#", 1)[0];
2541    }
2542    if ((0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.isDataScheme)(url)) {
2543      this._hideViewBookmark();
2544    }
2545    let title = (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.getPdfFilenameFromUrl)(url, "");
2546    if (!title) {
2547      try {
2548        title = decodeURIComponent((0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.getFilenameFromUrl)(url)) || url;
2549      } catch {
2550        title = url;
2551      }
2552    }
2553    this.setTitle(title);
2554  },
2555  setTitle(title = this._title) {
2556    this._title = title;
2557    if (this.isViewerEmbedded) {
2558      return;
2559    }
2560    const editorIndicator = this._hasAnnotationEditors && !this.pdfRenderingQueue.printing;
2561    document.title = `${editorIndicator ? "* " : ""}${title}`;
2562  },
2563  get _docFilename() {
2564    return this._contentDispositionFilename || (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.getPdfFilenameFromUrl)(this.url);
2565  },
2566  _hideViewBookmark() {
2567    const {
2568      secondaryToolbar
2569    } = this.appConfig;
2570    secondaryToolbar?.viewBookmarkButton.classList.add("hidden");
2571    if (secondaryToolbar?.presentationModeButton.classList.contains("hidden")) {
2572      document.getElementById("viewBookmarkSeparator")?.classList.add("hidden");
2573    }
2574  },
2575  async close() {
2576    this._unblockDocumentLoadEvent();
2577    this._hideViewBookmark();
2578    if (!this.pdfLoadingTask) {
2579      return;
2580    }
2581    if (this.pdfDocument?.annotationStorage.size > 0 && this._annotationStorageModified) {
2582      try {
2583        await this.save();
2584      } catch {}
2585    }
2586    const promises = [];
2587    promises.push(this.pdfLoadingTask.destroy());
2588    this.pdfLoadingTask = null;
2589    if (this.pdfDocument) {
2590      this.pdfDocument = null;
2591      this.pdfThumbnailViewer?.setDocument(null);
2592      this.pdfViewer.setDocument(null);
2593      this.pdfLinkService.setDocument(null);
2594      this.pdfDocumentProperties?.setDocument(null);
2595    }
2596    this.pdfLinkService.externalLinkEnabled = true;
2597    this.store = null;
2598    this.isInitialViewSet = false;
2599    this.downloadComplete = false;
2600    this.url = "";
2601    this.baseUrl = "";
2602    this._downloadUrl = "";
2603    this.documentInfo = null;
2604    this.metadata = null;
2605    this._contentDispositionFilename = null;
2606    this._contentLength = null;
2607    this._saveInProgress = false;
2608    this._hasAnnotationEditors = false;
2609    promises.push(this.pdfScriptingManager.destroyPromise, this.passwordPrompt.close());
2610    this.setTitle();
2611    this.pdfSidebar?.reset();
2612    this.pdfOutlineViewer?.reset();
2613    this.pdfAttachmentViewer?.reset();
2614    this.pdfLayerViewer?.reset();
2615    this.pdfHistory?.reset();
2616    this.findBar?.reset();
2617    this.toolbar?.reset();
2618    this.secondaryToolbar?.reset();
2619    this._PDFBug?.cleanup();
2620    await Promise.all(promises);
2621  },
2622  async open(args) {
2623    if (this.pdfLoadingTask) {
2624      await this.close();
2625    }
2626    const workerParams = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.getAll(_app_options_js__WEBPACK_IMPORTED_MODULE_2__.OptionKind.WORKER);
2627    Object.assign(pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.GlobalWorkerOptions, workerParams);
2628    if (args.url) {
2629      this.setTitleUsingUrl(args.originalUrl || args.url, args.url);
2630    }
2631    const apiParams = _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.getAll(_app_options_js__WEBPACK_IMPORTED_MODULE_2__.OptionKind.API);
2632    const loadingTask = (0,pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.getDocument)({
2633      ...apiParams,
2634      ...args
2635    });
2636    this.pdfLoadingTask = loadingTask;
2637    loadingTask.onPassword = (updateCallback, reason) => {
2638      if (this.isViewerEmbedded) {
2639        this._unblockDocumentLoadEvent();
2640      }
2641      this.pdfLinkService.externalLinkEnabled = false;

2642      this.passwordPrompt.setUpdateCallback(updateCallback, reason);
2643      this.passwordPrompt.open();
2644    };
2645    loadingTask.onProgress = ({
2646      loaded,
2647      total
2648    }) => {
2649      this.progress(loaded / total);
2650    };
2651    return loadingTask.promise.then(pdfDocument => {
2652      this.load(pdfDocument);
2653    }, reason => {
2654      if (loadingTask !== this.pdfLoadingTask) {
2655        return undefined;
2656      }
2657      let key = "pdfjs-loading-error";
2658      if (reason instanceof pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.InvalidPDFException) {
2659        key = "pdfjs-invalid-file-error";
2660      } else if (reason instanceof pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.MissingPDFException) {
2661        key = "pdfjs-missing-file-error";
2662      } else if (reason instanceof pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.UnexpectedResponseException) {
2663        key = "pdfjs-unexpected-response-error";
2664      }
2665      return this._documentError(key, {
2666        message: reason.message
2667      }).then(() => {
2668        throw reason;
2669      });
2670    });
2671  },
2672  _ensureDownloadComplete() {
2673    if (this.pdfDocument && this.downloadComplete) {
2674      return;
2675    }
2676    throw new Error("PDF document not downloaded.");
2677  },
2678  async download(options = {}) {
2679    const url = this._downloadUrl,
2680      filename = this._docFilename;
2681    try {
2682      this._ensureDownloadComplete();
2683      const data = await this.pdfDocument.getData();
2684      const blob = new Blob([data], {
2685        type: "application/pdf"
2686      });
2687      await this.downloadManager.download(blob, url, filename, options);
2688    } catch {
2689      await this.downloadManager.downloadUrl(url, filename, options);
2690    }
2691  },
2692  async save(options = {}) {
2693    if (this._saveInProgress) {
2694      return;
2695    }
2696    this._saveInProgress = true;
2697    await this.pdfScriptingManager.dispatchWillSave();
2698    const url = this._downloadUrl,
2699      filename = this._docFilename;
2700    try {
2701      this._ensureDownloadComplete();
2702      const data = await this.pdfDocument.saveDocument();
2703      const blob = new Blob([data], {
2704        type: "application/pdf"
2705      });
2706      await this.downloadManager.download(blob, url, filename, options);
2707    } catch (reason) {
2708      console.error(`Error when saving the document: ${reason.message}`);
2709      await this.download(options);
2710    } finally {
2711      await this.pdfScriptingManager.dispatchDidSave();
2712      this._saveInProgress = false;
2713    }
2714    if (this._hasAnnotationEditors) {
2715      this.externalServices.reportTelemetry({
2716        type: "editing",
2717        data: {
2718          type: "save",
2719          stats: this.pdfDocument?.annotationStorage.editorStats
2720        }
2721      });
2722    }
2723  },
2724  downloadOrSave(options = {}) {
2725    if (this.pdfDocument?.annotationStorage.size > 0) {
2726      this.save(options);
2727    } else {
2728      this.download(options);
2729    }
2730  },
2731  async _documentError(key, moreInfo = null) {
2732    this._unblockDocumentLoadEvent();
2733    const message = await this._otherError(key || "pdfjs-loading-error", moreInfo);
2734    this.eventBus.dispatch("documenterror", {
2735      source: this,
2736      message,
2737      reason: moreInfo?.message ?? null
2738    });
2739  },
2740  async _otherError(key, moreInfo = null) {
2741    const message = await this.l10n.get(key);
2742    const moreInfoText = [`PDF.js v${pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.version || "?"} (build: ${pdfjs_lib__WEBPACK_IMPORTED_MODULE_1__.build || "?"})`];
2743    if (moreInfo) {
2744      moreInfoText.push(`Message: ${moreInfo.message}`);
2745      if (moreInfo.stack) {
2746        moreInfoText.push(`Stack: ${moreInfo.stack}`);
2747      } else {
2748        if (moreInfo.filename) {
2749          moreInfoText.push(`File: ${moreInfo.filename}`);
2750        }
2751        if (moreInfo.lineNumber) {
2752          moreInfoText.push(`Line: ${moreInfo.lineNumber}`);
2753        }
2754      }
2755    }
2756    console.error(`${message}\n\n${moreInfoText.join("\n")}`);
2757    return message;
2758  },
2759  progress(level) {
2760    if (!this.loadingBar || this.downloadComplete) {
2761      return;
2762    }
2763    const percent = Math.round(level * 100);
2764    if (percent <= this.loadingBar.percent) {
2765      return;
2766    }
2767    this.loadingBar.percent = percent;
2768    if (this.pdfDocument?.loadingParams.disableAutoFetch ?? _app_options_js__WEBPACK_IMPORTED_MODULE_2__.AppOptions.get("disableAutoFetch")) {
2769      this.loadingBar.setDisableAutoFetch();
2770    }
2771  },
2772  load(pdfDocument) {
2773    this.pdfDocument = pdfDocument;
2774    pdfDocument.getDownloadInfo().then(({
2775      length
2776    }) => {
2777      this._contentLength = length;
2778      this.downloadComplete = true;
2779      this.loadingBar?.hide();
2780      firstPagePromise.then(() => {
2781        this.eventBus.dispatch("documentloaded", {
2782          source: this
2783        });
2784      });
2785    });
2786    const pageLayoutPromise = pdfDocument.getPageLayout().catch(() => {});
2787    const pageModePromise = pdfDocument.getPageMode().catch(() => {});
2788    const openActionPromise = pdfDocument.getOpenAction().catch(() => {});
2789    this.toolbar?.setPagesCount(pdfDocument.numPages, false);
2790    this.secondaryToolbar?.setPagesCount(pdfDocument.numPages);
2791    this.pdfLinkService.setDocument(pdfDocument);
2792    this.pdfDocumentProperties?.setDocument(pdfDocument);
2793    const pdfViewer = this.pdfViewer;
2794    pdfViewer.setDocument(pdfDocument);
2795    const {
2796      firstPagePromise,
2797      onePageRendered,
2798      pagesPromise
2799    } = pdfViewer;