{"version":3,"file":"static/js/9741.6e68f25f.chunk.js","mappings":"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","sources":["../node_modules/object-assign/index.js","../node_modules/promise-polyfill/src/finally.js","../node_modules/promise-polyfill/src/allSettled.js","../node_modules/promise-polyfill/src/any.js","../node_modules/promise-polyfill/src/index.js","../node_modules/@pixi/polyfill/src/globalThis.ts","../node_modules/@pixi/polyfill/src/Promise.ts","../node_modules/@pixi/polyfill/src/Object.assign.ts","../node_modules/@pixi/polyfill/src/requestAnimationFrame.ts","../node_modules/@pixi/polyfill/src/Math.sign.ts","../node_modules/@pixi/polyfill/src/Number.isInteger.ts","../node_modules/@pixi/polyfill/src/index.ts","../node_modules/@pixi/accessibility/src/accessibleTarget.ts","../node_modules/@pixi/accessibility/src/AccessibilityManager.ts","../node_modules/@pixi/interaction/src/InteractionData.ts","../node_modules/node_modules/tslib/tslib.es6.js","../node_modules/@pixi/interaction/src/InteractionEvent.ts","../node_modules/@pixi/interaction/src/InteractionTrackingData.ts","../node_modules/@pixi/interaction/src/TreeSearch.ts","../node_modules/@pixi/interaction/src/interactiveTarget.ts","../node_modules/@pixi/interaction/src/InteractionManager.ts","../node_modules/@pixi/compressed-textures/src/const.ts","../node_modules/@pixi/extract/src/Extract.ts","../node_modules/@pixi/compressed-textures/src/resources/BlobResource.ts","../node_modules/@pixi/compressed-textures/src/resources/CompressedTextureResource.ts","../node_modules/@pixi/compressed-textures/src/loaders/CompressedTextureLoader.ts","../node_modules/@pixi/compressed-textures/src/loaders/registerCompressedTextures.ts","../node_modules/@pixi/compressed-textures/src/parsers/parseDDS.ts","../node_modules/@pixi/compressed-textures/src/parsers/parseKTX.ts","../node_modules/@pixi/compressed-textures/src/loaders/DDSLoader.ts","../node_modules/@pixi/compressed-textures/src/loaders/KTXLoader.ts","../node_modules/@pixi/particle-container/src/ParticleContainer.ts","../node_modules/@pixi/text/src/const.ts","../node_modules/@pixi/particle-container/src/ParticleBuffer.ts","../node_modules/@pixi/particle-container/src/ParticleRenderer.ts","../node_modules/@pixi/text/src/TextStyle.ts","../node_modules/@pixi/text/src/TextMetrics.ts","../node_modules/@pixi/text/src/Text.ts","../node_modules/@pixi/prepare/src/settings.ts","../node_modules/@pixi/prepare/src/CountLimiter.ts","../node_modules/@pixi/prepare/src/BasePrepare.ts","../node_modules/@pixi/prepare/src/Prepare.ts","../node_modules/@pixi/prepare/src/TimeLimiter.ts","../node_modules/@pixi/spritesheet/src/Spritesheet.ts","../node_modules/@pixi/spritesheet/src/SpritesheetLoader.ts","../node_modules/@pixi/sprite-tiling/src/TilingSprite.ts","../node_modules/@pixi/sprite-tiling/src/TilingSpriteRenderer.ts","../node_modules/@pixi/text-bitmap/src/BitmapFontData.ts","../node_modules/@pixi/text-bitmap/src/formats/TextFormat.ts","../node_modules/@pixi/text-bitmap/src/formats/XMLFormat.ts","../node_modules/@pixi/text-bitmap/src/formats/XMLStringFormat.ts","../node_modules/@pixi/text-bitmap/src/formats/index.ts","../node_modules/@pixi/text-bitmap/src/utils/drawGlyph.ts","../node_modules/@pixi/text-bitmap/src/utils/generateFillStyle.ts","../node_modules/@pixi/text-bitmap/src/utils/splitTextToCharacters.ts","../node_modules/@pixi/text-bitmap/src/utils/extractCharCode.ts","../node_modules/@pixi/text-bitmap/src/BitmapFont.ts","../node_modules/@pixi/text-bitmap/src/utils/resolveCharacters.ts","../node_modules/@pixi/text-bitmap/src/BitmapText.ts","../node_modules/@pixi/text-bitmap/src/BitmapFontLoader.ts","../node_modules/@pixi/filter-alpha/src/AlphaFilter.ts","../node_modules/@pixi/filter-blur/src/generateBlurVertSource.ts","../node_modules/@pixi/filter-blur/src/generateBlurFragSource.ts","../node_modules/@pixi/filter-blur/src/BlurFilterPass.ts","../node_modules/@pixi/filter-blur/src/BlurFilter.ts","../node_modules/@pixi/filter-color-matrix/src/ColorMatrixFilter.ts","../node_modules/@pixi/filter-displacement/src/DisplacementFilter.ts","../node_modules/@pixi/filter-fxaa/src/FXAAFilter.ts","../node_modules/@pixi/filter-noise/src/NoiseFilter.ts","../node_modules/@pixi/mixin-cache-as-bitmap/src/index.ts","../node_modules/@pixi/mixin-get-child-by-name/src/index.ts","../node_modules/@pixi/mixin-get-global-position/src/index.ts","../node_modules/@pixi/app/src/ResizePlugin.ts","../node_modules/@pixi/app/src/Application.ts","../node_modules/@pixi/app/src/index.ts","../node_modules/@pixi/sprite-animated/src/AnimatedSprite.ts","../node_modules/pixi.js/src/index.ts","../node_modules/@pixi/canvas-renderer/src/utils/CanvasMaskManager.ts","../node_modules/@pixi/canvas-renderer/src/utils/canUseNewCanvasBlendModes.ts","../node_modules/@pixi/canvas-renderer/src/CanvasRenderer.ts","../node_modules/@pixi/canvas-renderer/src/utils/mapCanvasBlendModesToPixi.ts","../node_modules/@pixi/canvas-renderer/src/canvasUtils.ts","../node_modules/@pixi/canvas-renderer/src/Renderer.ts","../node_modules/@pixi/canvas-renderer/src/BaseTexture.ts","../node_modules/@pixi/canvas-mesh/src/CanvasMeshRenderer.ts","../node_modules/@pixi/canvas-mesh/src/settings.ts","../node_modules/@pixi/canvas-mesh/src/MeshMaterial.ts","../node_modules/@pixi/canvas-mesh/src/NineSlicePlane.ts","../node_modules/@pixi/canvas-mesh/src/Mesh.ts","../node_modules/@pixi/canvas-mesh/src/SimpleMesh.ts","../node_modules/@pixi/canvas-mesh/src/SimpleRope.ts","../node_modules/@pixi/canvas-graphics/src/utils/PolygonUtils.ts","../node_modules/@pixi/canvas-graphics/src/Graphics.ts","../node_modules/@pixi/canvas-graphics/src/CanvasGraphicsRenderer.ts","../node_modules/@pixi/canvas-sprite/src/CanvasSpriteRenderer.ts","../node_modules/@pixi/canvas-sprite/src/Sprite.ts","../node_modules/@pixi/canvas-extract/src/CanvasExtract.ts","../node_modules/@pixi/canvas-prepare/src/CanvasPrepare.ts","../node_modules/@pixi/canvas-sprite-tiling/src/TilingSprite.ts","../node_modules/@pixi/canvas-particle-container/src/ParticleContainer.ts","../node_modules/@pixi/canvas-display/src/Container.ts","../node_modules/@pixi/canvas-display/src/DisplayObject.ts","../node_modules/@pixi/canvas-text/src/Text.ts","../node_modules/pixi.js-legacy/src/index.ts"],"sourcesContent":["/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","/**\n * @this {Promise}\n */\nfunction finallyConstructor(callback) {\n  var constructor = this.constructor;\n  return this.then(\n    function(value) {\n      // @ts-ignore\n      return constructor.resolve(callback()).then(function() {\n        return value;\n      });\n    },\n    function(reason) {\n      // @ts-ignore\n      return constructor.resolve(callback()).then(function() {\n        // @ts-ignore\n        return constructor.reject(reason);\n      });\n    }\n  );\n}\n\nexport default finallyConstructor;\n","function allSettled(arr) {\n  var P = this;\n  return new P(function(resolve, reject) {\n    if (!(arr && typeof arr.length !== 'undefined')) {\n      return reject(\n        new TypeError(\n          typeof arr +\n            ' ' +\n            arr +\n            ' is not iterable(cannot read property Symbol(Symbol.iterator))'\n        )\n      );\n    }\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        var then = val.then;\n        if (typeof then === 'function') {\n          then.call(\n            val,\n            function(val) {\n              res(i, val);\n            },\n            function(e) {\n              args[i] = { status: 'rejected', reason: e };\n              if (--remaining === 0) {\n                resolve(args);\n              }\n            }\n          );\n          return;\n        }\n      }\n      args[i] = { status: 'fulfilled', value: val };\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n}\n\nexport default allSettled;\n","/**\n * @constructor\n */\nfunction AggregateError(errors, message) {\n  (this.name = 'AggregateError'), (this.errors = errors);\n  this.message = message || '';\n}\nAggregateError.prototype = Error.prototype;\n\nfunction any(arr) {\n  var P = this;\n  return new P(function(resolve, reject) {\n    if (!(arr && typeof arr.length !== 'undefined')) {\n      return reject(new TypeError('Promise.any accepts an array'));\n    }\n\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return reject();\n\n    var rejectionReasons = [];\n    for (var i = 0; i < args.length; i++) {\n      try {\n        P.resolve(args[i])\n          .then(resolve)\n          .catch(function(error) {\n            rejectionReasons.push(error);\n            if (rejectionReasons.length === args.length) {\n              reject(\n                new AggregateError(\n                  rejectionReasons,\n                  'All promises were rejected'\n                )\n              );\n            }\n          });\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n  });\n}\n\nexport default any;\n","import promiseFinally from './finally';\nimport allSettled from './allSettled';\nimport any from './any';\n\n// Store setTimeout reference so promise-polyfill will be unaffected by\n// other code modifying setTimeout (like sinon.useFakeTimers())\nvar setTimeoutFunc = setTimeout;\n\nfunction isArray(x) {\n  return Boolean(x && typeof x.length !== 'undefined');\n}\n\nfunction noop() {}\n\n// Polyfill for Function.prototype.bind\nfunction bind(fn, thisArg) {\n  return function() {\n    fn.apply(thisArg, arguments);\n  };\n}\n\n/**\n * @constructor\n * @param {Function} fn\n */\nfunction Promise(fn) {\n  if (!(this instanceof Promise))\n    throw new TypeError('Promises must be constructed via new');\n  if (typeof fn !== 'function') throw new TypeError('not a function');\n  /** @type {!number} */\n  this._state = 0;\n  /** @type {!boolean} */\n  this._handled = false;\n  /** @type {Promise|undefined} */\n  this._value = undefined;\n  /** @type {!Array<!Function>} */\n  this._deferreds = [];\n\n  doResolve(fn, this);\n}\n\nfunction handle(self, deferred) {\n  while (self._state === 3) {\n    self = self._value;\n  }\n  if (self._state === 0) {\n    self._deferreds.push(deferred);\n    return;\n  }\n  self._handled = true;\n  Promise._immediateFn(function() {\n    var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n      return;\n    }\n    var ret;\n    try {\n      ret = cb(self._value);\n    } catch (e) {\n      reject(deferred.promise, e);\n      return;\n    }\n    resolve(deferred.promise, ret);\n  });\n}\n\nfunction resolve(self, newValue) {\n  try {\n    // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n    if (newValue === self)\n      throw new TypeError('A promise cannot be resolved with itself.');\n    if (\n      newValue &&\n      (typeof newValue === 'object' || typeof newValue === 'function')\n    ) {\n      var then = newValue.then;\n      if (newValue instanceof Promise) {\n        self._state = 3;\n        self._value = newValue;\n        finale(self);\n        return;\n      } else if (typeof then === 'function') {\n        doResolve(bind(then, newValue), self);\n        return;\n      }\n    }\n    self._state = 1;\n    self._value = newValue;\n    finale(self);\n  } catch (e) {\n    reject(self, e);\n  }\n}\n\nfunction reject(self, newValue) {\n  self._state = 2;\n  self._value = newValue;\n  finale(self);\n}\n\nfunction finale(self) {\n  if (self._state === 2 && self._deferreds.length === 0) {\n    Promise._immediateFn(function() {\n      if (!self._handled) {\n        Promise._unhandledRejectionFn(self._value);\n      }\n    });\n  }\n\n  for (var i = 0, len = self._deferreds.length; i < len; i++) {\n    handle(self, self._deferreds[i]);\n  }\n  self._deferreds = null;\n}\n\n/**\n * @constructor\n */\nfunction Handler(onFulfilled, onRejected, promise) {\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, self) {\n  var done = false;\n  try {\n    fn(\n      function(value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      },\n      function(reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      }\n    );\n  } catch (ex) {\n    if (done) return;\n    done = true;\n    reject(self, ex);\n  }\n}\n\nPromise.prototype['catch'] = function(onRejected) {\n  return this.then(null, onRejected);\n};\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  // @ts-ignore\n  var prom = new this.constructor(noop);\n\n  handle(this, new Handler(onFulfilled, onRejected, prom));\n  return prom;\n};\n\nPromise.prototype['finally'] = promiseFinally;\n\nPromise.all = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!isArray(arr)) {\n      return reject(new TypeError('Promise.all accepts an array'));\n    }\n\n    var args = Array.prototype.slice.call(arr);\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n\n    function res(i, val) {\n      try {\n        if (val && (typeof val === 'object' || typeof val === 'function')) {\n          var then = val.then;\n          if (typeof then === 'function') {\n            then.call(\n              val,\n              function(val) {\n                res(i, val);\n              },\n              reject\n            );\n            return;\n          }\n        }\n        args[i] = val;\n        if (--remaining === 0) {\n          resolve(args);\n        }\n      } catch (ex) {\n        reject(ex);\n      }\n    }\n\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.any = any;\n\nPromise.allSettled = allSettled;\n\nPromise.resolve = function(value) {\n  if (value && typeof value === 'object' && value.constructor === Promise) {\n    return value;\n  }\n\n  return new Promise(function(resolve) {\n    resolve(value);\n  });\n};\n\nPromise.reject = function(value) {\n  return new Promise(function(resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function(arr) {\n  return new Promise(function(resolve, reject) {\n    if (!isArray(arr)) {\n      return reject(new TypeError('Promise.race accepts an array'));\n    }\n\n    for (var i = 0, len = arr.length; i < len; i++) {\n      Promise.resolve(arr[i]).then(resolve, reject);\n    }\n  });\n};\n\n// Use polyfill for setImmediate for performance gains\nPromise._immediateFn =\n  // @ts-ignore\n  (typeof setImmediate === 'function' &&\n    function(fn) {\n      // @ts-ignore\n      setImmediate(fn);\n    }) ||\n  function(fn) {\n    setTimeoutFunc(fn, 0);\n  };\n\nPromise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n  if (typeof console !== 'undefined' && console) {\n    console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n  }\n};\n\nexport default Promise;\n","if (typeof globalThis === 'undefined')\n{\n    if (typeof self !== 'undefined')\n    {\n        // covers browsers\n        // @ts-expect-error not-writable ts(2540) error only on node\n        self.globalThis = self;\n    }\n    else if (typeof global !== 'undefined')\n    {\n        // covers versions of Node < 12\n        // @ts-expect-error not-writable ts(2540) error only on node\n        global.globalThis = global;\n    }\n}\n","import Polyfill from 'promise-polyfill';\n\n// Support for IE 9 - 11 which does not include Promises\nif (!globalThis.Promise)\n{\n    globalThis.Promise = Polyfill;\n}\n","// References:\n// https://github.com/sindresorhus/object-assign\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n\nimport objectAssign from 'object-assign';\n\nif (!Object.assign)\n{\n    Object.assign = objectAssign;\n}\n","// References:\n// http://paulirish.com/2011/requestanimationframe-for-smart-animating/\n// https://gist.github.com/1579671\n// http://updates.html5rocks.com/2012/05/requestAnimationFrame-API-now-with-sub-millisecond-precision\n// https://gist.github.com/timhall/4078614\n// https://github.com/Financial-Times/polyfill-service/tree/master/polyfills/requestAnimationFrame\n\n// Expected to be used with Browserfiy\n// Browserify automatically detects the use of `global` and passes the\n// correct reference of `global`, `globalThis`, and finally `window`\n\nconst ONE_FRAME_TIME = 16;\n\n// Date.now\nif (!(Date.now && Date.prototype.getTime))\n{\n    Date.now = function now(): number\n    {\n        return new Date().getTime();\n    };\n}\n\n// performance.now\nif (!(globalThis.performance && globalThis.performance.now))\n{\n    const startTime = Date.now();\n\n    if (!globalThis.performance)\n    {\n        (globalThis as any).performance = {};\n    }\n\n    globalThis.performance.now = (): number => Date.now() - startTime;\n}\n\n// requestAnimationFrame\nlet lastTime = Date.now();\nconst vendors = ['ms', 'moz', 'webkit', 'o'];\n\nfor (let x = 0; x < vendors.length && !globalThis.requestAnimationFrame; ++x)\n{\n    const p = vendors[x];\n\n    globalThis.requestAnimationFrame = (globalThis as any)[`${p}RequestAnimationFrame`];\n    globalThis.cancelAnimationFrame = (globalThis as any)[`${p}CancelAnimationFrame`]\n        || (globalThis as any)[`${p}CancelRequestAnimationFrame`];\n}\n\nif (!globalThis.requestAnimationFrame)\n{\n    globalThis.requestAnimationFrame = (callback: (...parms: any[]) => void): number =>\n    {\n        if (typeof callback !== 'function')\n        {\n            throw new TypeError(`${callback}is not a function`);\n        }\n\n        const currentTime = Date.now();\n        let delay = ONE_FRAME_TIME + lastTime - currentTime;\n\n        if (delay < 0)\n        {\n            delay = 0;\n        }\n\n        lastTime = currentTime;\n\n        return globalThis.self.setTimeout(() =>\n        {\n            lastTime = Date.now();\n            callback(performance.now());\n        }, delay);\n    };\n}\n\nif (!globalThis.cancelAnimationFrame)\n{\n    globalThis.cancelAnimationFrame = (id: number): void => clearTimeout(id);\n}\n","// References:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign\n\nif (!Math.sign)\n{\n    Math.sign = function mathSign(x): number\n    {\n        x = Number(x);\n\n        if (x === 0 || isNaN(x))\n        {\n            return x;\n        }\n\n        return x > 0 ? 1 : -1;\n    };\n}\n","// References:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger\n\nif (!Number.isInteger)\n{\n    Number.isInteger = function numberIsInteger(value): boolean\n    {\n        return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;\n    };\n}\n","import './globalThis';\nimport './Promise';\nimport './Object.assign';\nimport './requestAnimationFrame';\nimport './Math.sign';\nimport './Number.isInteger';\n\nif (!globalThis.ArrayBuffer)\n{\n    (globalThis as any).ArrayBuffer = Array;\n}\n\nif (!globalThis.Float32Array)\n{\n    (globalThis as any).Float32Array = Array;\n}\n\nif (!globalThis.Uint32Array)\n{\n    (globalThis as any).Uint32Array = Array;\n}\n\nif (!globalThis.Uint16Array)\n{\n    (globalThis as any).Uint16Array = Array;\n}\n\nif (!globalThis.Uint8Array)\n{\n    (globalThis as any).Uint8Array = Array;\n}\n\nif (!globalThis.Int32Array)\n{\n    (globalThis as any).Int32Array = Array;\n}\n","import type { DisplayObject } from '@pixi/display';\n\nexport type PointerEvents = 'auto'\n| 'none'\n| 'visiblePainted'\n| 'visibleFill'\n| 'visibleStroke'\n| 'visible'\n| 'painted'\n| 'fill'\n| 'stroke'\n| 'all'\n| 'inherit';\n\nexport interface IAccessibleTarget\n{\n    accessible: boolean;\n    accessibleTitle: string;\n    accessibleHint: string;\n    tabIndex: number;\n    _accessibleActive: boolean;\n    _accessibleDiv: IAccessibleHTMLElement;\n    accessibleType: string;\n    accessiblePointerEvents: PointerEvents;\n    accessibleChildren: boolean;\n    renderId: number;\n}\n\nexport interface IAccessibleHTMLElement extends HTMLElement\n{\n    type?: string;\n    displayObject?: DisplayObject;\n}\n\n/**\n * Default property values of accessible objects\n * used by {@link PIXI.AccessibilityManager}.\n * @private\n * @function accessibleTarget\n * @memberof PIXI\n * @type {object}\n * @example\n *      function MyObject() {}\n *\n *      Object.assign(\n *          MyObject.prototype,\n *          PIXI.accessibleTarget\n *      );\n */\nexport const accessibleTarget: IAccessibleTarget = {\n    /**\n     *  Flag for if the object is accessible. If true AccessibilityManager will overlay a\n     *   shadow div with attributes set\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     */\n    accessible: false,\n\n    /**\n     * Sets the title attribute of the shadow div\n     * If accessibleTitle AND accessibleHint has not been this will default to 'displayObject [tabIndex]'\n     * @member {?string}\n     * @memberof PIXI.DisplayObject#\n     */\n    accessibleTitle: null,\n\n    /**\n     * Sets the aria-label attribute of the shadow div\n     * @member {string}\n     * @memberof PIXI.DisplayObject#\n     */\n    accessibleHint: null,\n\n    /**\n     * @member {number}\n     * @memberof PIXI.DisplayObject#\n     * @private\n     * @todo Needs docs.\n     */\n    tabIndex: 0,\n\n    /**\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     * @todo Needs docs.\n     */\n    _accessibleActive: false,\n\n    /**\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     * @todo Needs docs.\n     */\n    _accessibleDiv: null,\n\n    /**\n     * Specify the type of div the accessible layer is. Screen readers treat the element differently\n     * depending on this type. Defaults to button.\n     * @member {string}\n     * @memberof PIXI.DisplayObject#\n     * @default 'button'\n     */\n    accessibleType: 'button',\n\n    /**\n     * Specify the pointer-events the accessible div will use\n     * Defaults to auto.\n     * @member {string}\n     * @memberof PIXI.DisplayObject#\n     * @default 'auto'\n     */\n    accessiblePointerEvents: 'auto',\n\n    /**\n     * Setting to false will prevent any children inside this container to\n     * be accessible. Defaults to true.\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     * @default true\n     */\n    accessibleChildren: true,\n\n    renderId: -1,\n};\n","import { DisplayObject } from '@pixi/display';\nimport { isMobile, removeItems } from '@pixi/utils';\nimport { accessibleTarget } from './accessibleTarget';\n\nimport type { Rectangle } from '@pixi/math';\nimport type { Container } from '@pixi/display';\nimport type { Renderer, AbstractRenderer, ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\nimport type { IAccessibleHTMLElement } from './accessibleTarget';\n\n// add some extra variables to the container..\nDisplayObject.mixin(accessibleTarget);\n\nconst KEY_CODE_TAB = 9;\n\nconst DIV_TOUCH_SIZE = 100;\nconst DIV_TOUCH_POS_X = 0;\nconst DIV_TOUCH_POS_Y = 0;\nconst DIV_TOUCH_ZINDEX = 2;\n\nconst DIV_HOOK_SIZE = 1;\nconst DIV_HOOK_POS_X = -1000;\nconst DIV_HOOK_POS_Y = -1000;\nconst DIV_HOOK_ZINDEX = 2;\n\n/**\n * The Accessibility manager recreates the ability to tab and have content read by screen readers.\n * This is very important as it can possibly help people with disabilities access PixiJS content.\n *\n * A DisplayObject can be made accessible just like it can be made interactive. This manager will map the\n * events as if the mouse was being used, minimizing the effort required to implement.\n *\n * An instance of this class is automatically created by default, and can be found at `renderer.plugins.accessibility`\n * @class\n * @memberof PIXI\n */\nexport class AccessibilityManager\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'accessibility',\n        type: [\n            ExtensionType.RendererPlugin,\n            ExtensionType.CanvasRendererPlugin,\n        ],\n    };\n\n    /** Setting this to true will visually show the divs. */\n    public debug = false;\n\n    /**\n     * The renderer this accessibility manager works for.\n     * @type {PIXI.CanvasRenderer|PIXI.Renderer}\n     */\n    public renderer: AbstractRenderer | Renderer;\n\n    /** Internal variable, see isActive getter. */\n    private _isActive = false;\n\n    /** Internal variable, see isMobileAccessibility getter. */\n    private _isMobileAccessibility = false;\n\n    /** Button element for handling touch hooks. */\n    private _hookDiv: HTMLElement;\n\n    /** This is the dom element that will sit over the PixiJS element. This is where the div overlays will go. */\n    private div: HTMLElement;\n\n    /** A simple pool for storing divs. */\n    private pool: IAccessibleHTMLElement[] = [];\n\n    /** This is a tick used to check if an object is no longer being rendered. */\n    private renderId = 0;\n\n    /** The array of currently active accessible items. */\n    private children: DisplayObject[] = [];\n\n    /** Count to throttle div updates on android devices. */\n    private androidUpdateCount = 0;\n\n    /**  The frequency to update the div elements. */\n    private androidUpdateFrequency = 500; // 2fps\n\n    /**\n     * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer\n     */\n    constructor(renderer: AbstractRenderer | Renderer)\n    {\n        this._hookDiv = null;\n\n        if (isMobile.tablet || isMobile.phone)\n        {\n            this.createTouchHook();\n        }\n\n        // first we create a div that will sit over the PixiJS element. This is where the div overlays will go.\n        const div = document.createElement('div');\n\n        div.style.width = `${DIV_TOUCH_SIZE}px`;\n        div.style.height = `${DIV_TOUCH_SIZE}px`;\n        div.style.position = 'absolute';\n        div.style.top = `${DIV_TOUCH_POS_X}px`;\n        div.style.left = `${DIV_TOUCH_POS_Y}px`;\n        div.style.zIndex = DIV_TOUCH_ZINDEX.toString();\n\n        this.div = div;\n        this.renderer = renderer;\n\n        /**\n         * pre-bind the functions\n         * @type {Function}\n         * @private\n         */\n        this._onKeyDown = this._onKeyDown.bind(this);\n\n        /**\n         * pre-bind the functions\n         * @type {Function}\n         * @private\n         */\n        this._onMouseMove = this._onMouseMove.bind(this);\n\n        // let listen for tab.. once pressed we can fire up and show the accessibility layer\n        globalThis.addEventListener('keydown', this._onKeyDown, false);\n    }\n\n    /**\n     * Value of `true` if accessibility is currently active and accessibility layers are showing.\n     * @member {boolean}\n     * @readonly\n     */\n    get isActive(): boolean\n    {\n        return this._isActive;\n    }\n\n    /**\n     * Value of `true` if accessibility is enabled for touch devices.\n     * @member {boolean}\n     * @readonly\n     */\n    get isMobileAccessibility(): boolean\n    {\n        return this._isMobileAccessibility;\n    }\n\n    /**\n     * Creates the touch hooks.\n     * @private\n     */\n    private createTouchHook(): void\n    {\n        const hookDiv = document.createElement('button');\n\n        hookDiv.style.width = `${DIV_HOOK_SIZE}px`;\n        hookDiv.style.height = `${DIV_HOOK_SIZE}px`;\n        hookDiv.style.position = 'absolute';\n        hookDiv.style.top = `${DIV_HOOK_POS_X}px`;\n        hookDiv.style.left = `${DIV_HOOK_POS_Y}px`;\n        hookDiv.style.zIndex = DIV_HOOK_ZINDEX.toString();\n        hookDiv.style.backgroundColor = '#FF0000';\n        hookDiv.title = 'select to enable accessibility for this content';\n\n        hookDiv.addEventListener('focus', () =>\n        {\n            this._isMobileAccessibility = true;\n            this.activate();\n            this.destroyTouchHook();\n        });\n\n        document.body.appendChild(hookDiv);\n        this._hookDiv = hookDiv;\n    }\n\n    /**\n     * Destroys the touch hooks.\n     * @private\n     */\n    private destroyTouchHook(): void\n    {\n        if (!this._hookDiv)\n        {\n            return;\n        }\n        document.body.removeChild(this._hookDiv);\n        this._hookDiv = null;\n    }\n\n    /**\n     * Activating will cause the Accessibility layer to be shown.\n     * This is called when a user presses the tab key.\n     * @private\n     */\n    private activate(): void\n    {\n        if (this._isActive)\n        {\n            return;\n        }\n\n        this._isActive = true;\n\n        globalThis.document.addEventListener('mousemove', this._onMouseMove, true);\n        globalThis.removeEventListener('keydown', this._onKeyDown, false);\n\n        this.renderer.on('postrender', this.update, this);\n        this.renderer.view.parentNode?.appendChild(this.div);\n    }\n\n    /**\n     * Deactivating will cause the Accessibility layer to be hidden.\n     * This is called when a user moves the mouse.\n     * @private\n     */\n    private deactivate(): void\n    {\n        if (!this._isActive || this._isMobileAccessibility)\n        {\n            return;\n        }\n\n        this._isActive = false;\n\n        globalThis.document.removeEventListener('mousemove', this._onMouseMove, true);\n        globalThis.addEventListener('keydown', this._onKeyDown, false);\n\n        this.renderer.off('postrender', this.update);\n        this.div.parentNode?.removeChild(this.div);\n    }\n\n    /**\n     * This recursive function will run through the scene graph and add any new accessible objects to the DOM layer.\n     * @private\n     * @param {PIXI.Container} displayObject - The DisplayObject to check.\n     */\n    private updateAccessibleObjects(displayObject: Container): void\n    {\n        if (!displayObject.visible || !displayObject.accessibleChildren)\n        {\n            return;\n        }\n\n        if (displayObject.accessible && displayObject.interactive)\n        {\n            if (!displayObject._accessibleActive)\n            {\n                this.addChild(displayObject);\n            }\n\n            displayObject.renderId = this.renderId;\n        }\n\n        const children = displayObject.children;\n\n        if (children)\n        {\n            for (let i = 0; i < children.length; i++)\n            {\n                this.updateAccessibleObjects(children[i] as Container);\n            }\n        }\n    }\n\n    /**\n     * Before each render this function will ensure that all divs are mapped correctly to their DisplayObjects.\n     * @private\n     */\n    private update(): void\n    {\n        /* On Android default web browser, tab order seems to be calculated by position rather than tabIndex,\n        *  moving buttons can cause focus to flicker between two buttons making it hard/impossible to navigate,\n        *  so I am just running update every half a second, seems to fix it.\n        */\n        const now = performance.now();\n\n        if (isMobile.android.device && now < this.androidUpdateCount)\n        {\n            return;\n        }\n\n        this.androidUpdateCount = now + this.androidUpdateFrequency;\n\n        if (!(this.renderer as Renderer).renderingToScreen)\n        {\n            return;\n        }\n\n        // update children...\n        if (this.renderer._lastObjectRendered)\n        {\n            this.updateAccessibleObjects(this.renderer._lastObjectRendered as Container);\n        }\n\n        const { left, top, width, height } = this.renderer.view.getBoundingClientRect();\n        const { width: viewWidth, height: viewHeight, resolution } = this.renderer;\n\n        const sx = (width / viewWidth) * resolution;\n        const sy = (height / viewHeight) * resolution;\n\n        let div = this.div;\n\n        div.style.left = `${left}px`;\n        div.style.top = `${top}px`;\n        div.style.width = `${viewWidth}px`;\n        div.style.height = `${viewHeight}px`;\n\n        for (let i = 0; i < this.children.length; i++)\n        {\n            const child = this.children[i];\n\n            if (child.renderId !== this.renderId)\n            {\n                child._accessibleActive = false;\n\n                removeItems(this.children, i, 1);\n                this.div.removeChild(child._accessibleDiv);\n                this.pool.push(child._accessibleDiv);\n                child._accessibleDiv = null;\n\n                i--;\n            }\n            else\n            {\n                // map div to display..\n                div = child._accessibleDiv;\n                let hitArea = child.hitArea as Rectangle;\n                const wt = child.worldTransform;\n\n                if (child.hitArea)\n                {\n                    div.style.left = `${(wt.tx + (hitArea.x * wt.a)) * sx}px`;\n                    div.style.top = `${(wt.ty + (hitArea.y * wt.d)) * sy}px`;\n\n                    div.style.width = `${hitArea.width * wt.a * sx}px`;\n                    div.style.height = `${hitArea.height * wt.d * sy}px`;\n                }\n                else\n                {\n                    hitArea = child.getBounds();\n\n                    this.capHitArea(hitArea);\n\n                    div.style.left = `${hitArea.x * sx}px`;\n                    div.style.top = `${hitArea.y * sy}px`;\n\n                    div.style.width = `${hitArea.width * sx}px`;\n                    div.style.height = `${hitArea.height * sy}px`;\n\n                    // update button titles and hints if they exist and they've changed\n                    if (div.title !== child.accessibleTitle && child.accessibleTitle !== null)\n                    {\n                        div.title = child.accessibleTitle;\n                    }\n                    if (div.getAttribute('aria-label') !== child.accessibleHint\n                        && child.accessibleHint !== null)\n                    {\n                        div.setAttribute('aria-label', child.accessibleHint);\n                    }\n                }\n\n                // the title or index may have changed, if so lets update it!\n                if (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex)\n                {\n                    div.title = child.accessibleTitle;\n                    div.tabIndex = child.tabIndex;\n                    if (this.debug) this.updateDebugHTML(div);\n                }\n            }\n        }\n\n        // increment the render id..\n        this.renderId++;\n    }\n\n    /**\n     * private function that will visually add the information to the\n     * accessability div\n     * @param {HTMLElement} div -\n     */\n    public updateDebugHTML(div: IAccessibleHTMLElement): void\n    {\n        div.innerHTML = `type: ${div.type}</br> title : ${div.title}</br> tabIndex: ${div.tabIndex}`;\n    }\n\n    /**\n     * Adjust the hit area based on the bounds of a display object\n     * @param {PIXI.Rectangle} hitArea - Bounds of the child\n     */\n    public capHitArea(hitArea: Rectangle): void\n    {\n        if (hitArea.x < 0)\n        {\n            hitArea.width += hitArea.x;\n            hitArea.x = 0;\n        }\n\n        if (hitArea.y < 0)\n        {\n            hitArea.height += hitArea.y;\n            hitArea.y = 0;\n        }\n\n        const { width: viewWidth, height: viewHeight } = this.renderer;\n\n        if (hitArea.x + hitArea.width > viewWidth)\n        {\n            hitArea.width = viewWidth - hitArea.x;\n        }\n\n        if (hitArea.y + hitArea.height > viewHeight)\n        {\n            hitArea.height = viewHeight - hitArea.y;\n        }\n    }\n\n    /**\n     * Adds a DisplayObject to the accessibility manager\n     * @private\n     * @param {PIXI.DisplayObject} displayObject - The child to make accessible.\n     */\n    private addChild<T extends DisplayObject>(displayObject: T): void\n    {\n        //    this.activate();\n\n        let div = this.pool.pop();\n\n        if (!div)\n        {\n            div = document.createElement('button');\n\n            div.style.width = `${DIV_TOUCH_SIZE}px`;\n            div.style.height = `${DIV_TOUCH_SIZE}px`;\n            div.style.backgroundColor = this.debug ? 'rgba(255,255,255,0.5)' : 'transparent';\n            div.style.position = 'absolute';\n            div.style.zIndex = DIV_TOUCH_ZINDEX.toString();\n            div.style.borderStyle = 'none';\n\n            // ARIA attributes ensure that button title and hint updates are announced properly\n            if (navigator.userAgent.toLowerCase().indexOf('chrome') > -1)\n            {\n                // Chrome doesn't need aria-live to work as intended; in fact it just gets more confused.\n                div.setAttribute('aria-live', 'off');\n            }\n            else\n            {\n                div.setAttribute('aria-live', 'polite');\n            }\n\n            if (navigator.userAgent.match(/rv:.*Gecko\\//))\n            {\n                // FireFox needs this to announce only the new button name\n                div.setAttribute('aria-relevant', 'additions');\n            }\n            else\n            {\n                // required by IE, other browsers don't much care\n                div.setAttribute('aria-relevant', 'text');\n            }\n\n            div.addEventListener('click', this._onClick.bind(this));\n            div.addEventListener('focus', this._onFocus.bind(this));\n            div.addEventListener('focusout', this._onFocusOut.bind(this));\n        }\n\n        // set pointer events\n        div.style.pointerEvents = displayObject.accessiblePointerEvents;\n        // set the type, this defaults to button!\n        div.type = displayObject.accessibleType;\n\n        if (displayObject.accessibleTitle && displayObject.accessibleTitle !== null)\n        {\n            div.title = displayObject.accessibleTitle;\n        }\n        else if (!displayObject.accessibleHint\n                 || displayObject.accessibleHint === null)\n        {\n            div.title = `displayObject ${displayObject.tabIndex}`;\n        }\n\n        if (displayObject.accessibleHint\n            && displayObject.accessibleHint !== null)\n        {\n            div.setAttribute('aria-label', displayObject.accessibleHint);\n        }\n\n        if (this.debug) this.updateDebugHTML(div);\n\n        displayObject._accessibleActive = true;\n        displayObject._accessibleDiv = div;\n        div.displayObject = displayObject;\n\n        this.children.push(displayObject);\n        this.div.appendChild(displayObject._accessibleDiv);\n        displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;\n    }\n\n    /**\n     * Maps the div button press to pixi's InteractionManager (click)\n     * @private\n     * @param {MouseEvent} e - The click event.\n     */\n    private _onClick(e: MouseEvent): void\n    {\n        const interactionManager = this.renderer.plugins.interaction;\n        const { displayObject } = e.target as IAccessibleHTMLElement;\n        const { eventData } = interactionManager;\n\n        interactionManager.dispatchEvent(displayObject, 'click', eventData);\n        interactionManager.dispatchEvent(displayObject, 'pointertap', eventData);\n        interactionManager.dispatchEvent(displayObject, 'tap', eventData);\n    }\n\n    /**\n     * Maps the div focus events to pixi's InteractionManager (mouseover)\n     * @private\n     * @param {FocusEvent} e - The focus event.\n     */\n    private _onFocus(e: FocusEvent): void\n    {\n        if (!(e.target as Element).getAttribute('aria-live'))\n        {\n            (e.target as Element).setAttribute('aria-live', 'assertive');\n        }\n\n        const interactionManager = this.renderer.plugins.interaction;\n        const { displayObject } = e.target as IAccessibleHTMLElement;\n        const { eventData } = interactionManager;\n\n        interactionManager.dispatchEvent(displayObject, 'mouseover', eventData);\n    }\n\n    /**\n     * Maps the div focus events to pixi's InteractionManager (mouseout)\n     * @private\n     * @param {FocusEvent} e - The focusout event.\n     */\n    private _onFocusOut(e: FocusEvent): void\n    {\n        if (!(e.target as Element).getAttribute('aria-live'))\n        {\n            (e.target as Element).setAttribute('aria-live', 'polite');\n        }\n\n        const interactionManager = this.renderer.plugins.interaction;\n        const { displayObject } = e.target as IAccessibleHTMLElement;\n        const { eventData } = interactionManager;\n\n        interactionManager.dispatchEvent(displayObject, 'mouseout', eventData);\n    }\n\n    /**\n     * Is called when a key is pressed\n     * @private\n     * @param {KeyboardEvent} e - The keydown event.\n     */\n    private _onKeyDown(e: KeyboardEvent): void\n    {\n        if (e.keyCode !== KEY_CODE_TAB)\n        {\n            return;\n        }\n\n        this.activate();\n    }\n\n    /**\n     * Is called when the mouse moves across the renderer element\n     * @private\n     * @param {MouseEvent} e - The mouse event.\n     */\n    private _onMouseMove(e: MouseEvent): void\n    {\n        if (e.movementX === 0 && e.movementY === 0)\n        {\n            return;\n        }\n\n        this.deactivate();\n    }\n\n    /** Destroys the accessibility manager */\n    public destroy(): void\n    {\n        this.destroyTouchHook();\n        this.div = null;\n\n        globalThis.document.removeEventListener('mousemove', this._onMouseMove, true);\n        globalThis.removeEventListener('keydown', this._onKeyDown);\n\n        this.pool = null;\n        this.children = null;\n        this.renderer = null;\n    }\n}\n","import type { IPointData } from '@pixi/math';\nimport { Point } from '@pixi/math';\n\nimport type { DisplayObject } from '@pixi/display';\n\nexport type InteractivePointerEvent = PointerEvent | TouchEvent | MouseEvent;\n\n/**\n * Holds all information related to an Interaction event\n * @memberof PIXI\n */\nexport class InteractionData\n{\n    /** This point stores the global coords of where the touch/mouse event happened. */\n    public global: Point;\n\n    /** The target Sprite that was interacted with. */\n    public target: DisplayObject;\n\n    /**\n     * When passed to an event handler, this will be the original DOM Event that was captured\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent\n     * @member {MouseEvent|TouchEvent|PointerEvent}\n     */\n    public originalEvent: InteractivePointerEvent;\n\n    /** Unique identifier for this interaction. */\n    public identifier: number;\n\n    /**\n     * Indicates whether or not the pointer device that created the event is the primary pointer.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/isPrimary\n     */\n    public isPrimary: boolean;\n\n    /**\n     * Indicates which button was pressed on the mouse or pointer device to trigger the event.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n     */\n    public button: number;\n\n    /**\n     * Indicates which buttons are pressed on the mouse or pointer device when the event is triggered.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons\n     */\n    public buttons: number;\n\n    /**\n     * The width of the pointer's contact along the x-axis, measured in CSS pixels.\n     * radiusX of TouchEvents will be represented by this value.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/width\n     */\n    public width: number;\n\n    /**\n     * The height of the pointer's contact along the y-axis, measured in CSS pixels.\n     * radiusY of TouchEvents will be represented by this value.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/height\n     */\n    public height: number;\n\n    /**\n     * The angle, in degrees, between the pointer device and the screen.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltX\n     */\n    public tiltX: number;\n\n    /**\n     * The angle, in degrees, between the pointer device and the screen.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/tiltY\n     */\n    public tiltY: number;\n\n    /**\n     * The type of pointer that triggered the event.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerType\n     */\n    public pointerType: string;\n\n    /**\n     * Pressure applied by the pointing device during the event. A Touch's force property\n     * will be represented by this value.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pressure\n     */\n    public pressure = 0;\n\n    /**\n     * From TouchEvents (not PointerEvents triggered by touches), the rotationAngle of the Touch.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Touch/rotationAngle\n     */\n    public rotationAngle = 0;\n\n    /**\n     * Twist of a stylus pointer.\n     * @see https://w3c.github.io/pointerevents/#pointerevent-interface\n     */\n    public twist = 0;\n\n    /**\n     * Barrel pressure on a stylus pointer.\n     * @see https://w3c.github.io/pointerevents/#pointerevent-interface\n     */\n    public tangentialPressure = 0;\n\n    constructor()\n    {\n        this.global = new Point();\n        this.target = null;\n        this.originalEvent = null;\n        this.identifier = null;\n        this.isPrimary = false;\n        this.button = 0;\n        this.buttons = 0;\n        this.width = 0;\n        this.height = 0;\n        this.tiltX = 0;\n        this.tiltY = 0;\n        this.pointerType = null;\n        this.pressure = 0;\n        this.rotationAngle = 0;\n        this.twist = 0;\n        this.tangentialPressure = 0;\n    }\n\n    /**\n     * The unique identifier of the pointer. It will be the same as `identifier`.\n     * @readonly\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerId\n     */\n    get pointerId(): number\n    {\n        return this.identifier;\n    }\n\n    /**\n     * This will return the local coordinates of the specified displayObject for this InteractionData\n     * @param displayObject - The DisplayObject that you would like the local\n     *  coords off\n     * @param point - A Point object in which to store the value, optional (otherwise\n     *  will create a new point)\n     * @param globalPos - A Point object containing your custom global coords, optional\n     *  (otherwise will use the current global coords)\n     * @returns - A point containing the coordinates of the InteractionData position relative\n     *  to the DisplayObject\n     */\n    public getLocalPosition<P extends IPointData = Point>(displayObject: DisplayObject, point?: P, globalPos?: IPointData): P\n    {\n        return displayObject.worldTransform.applyInverse<P>(globalPos || this.global, point);\n    }\n\n    /**\n     * Copies properties from normalized event data.\n     * @param {Touch|MouseEvent|PointerEvent} event - The normalized event data\n     */\n    public copyEvent(event: Touch | InteractivePointerEvent): void\n    {\n        // isPrimary should only change on touchstart/pointerdown, so we don't want to overwrite\n        // it with \"false\" on later events when our shim for it on touch events might not be\n        // accurate\n        if ('isPrimary' in event && event.isPrimary)\n        {\n            this.isPrimary = true;\n        }\n        this.button = 'button' in event && event.button;\n        // event.buttons is not available in all browsers (ie. Safari), but it does have a non-standard\n        // event.which property instead, which conveys the same information.\n        const buttons = 'buttons' in event && event.buttons;\n\n        this.buttons = Number.isInteger(buttons) ? buttons : 'which' in event && event.which;\n        this.width = 'width' in event && event.width;\n        this.height = 'height' in event && event.height;\n        this.tiltX = 'tiltX' in event && event.tiltX;\n        this.tiltY = 'tiltY' in event && event.tiltY;\n        this.pointerType = 'pointerType' in event && event.pointerType;\n        this.pressure = 'pressure' in event && event.pressure;\n        this.rotationAngle = 'rotationAngle' in event && event.rotationAngle;\n        this.twist = ('twist' in event && event.twist) || 0;\n        this.tangentialPressure = ('tangentialPressure' in event && event.tangentialPressure) || 0;\n    }\n\n    /** Resets the data for pooling. */\n    public reset(): void\n    {\n        // isPrimary is the only property that we really need to reset - everything else is\n        // guaranteed to be overwritten\n        this.isPrimary = false;\n    }\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import type { DisplayObject } from '@pixi/display';\nimport type { InteractionData } from './InteractionData';\n\nexport type InteractionCallback = (interactionEvent: InteractionEvent, displayObject: DisplayObject, hit?: boolean) => void;\n\n/**\n * Event class that mimics native DOM events.\n * @memberof PIXI\n */\nexport class InteractionEvent\n{\n    /**\n     * Whether this event will continue propagating in the tree.\n     *\n     * Remaining events for the {@link stopsPropagatingAt} object\n     * will still be dispatched.\n     */\n    public stopped: boolean;\n\n    /**\n     * At which object this event stops propagating.\n     * @private\n     */\n    public stopsPropagatingAt: DisplayObject;\n\n    /**\n     * Whether we already reached the element we want to\n     * stop propagating at. This is important for delayed events,\n     * where we start over deeper in the tree again.\n     * @private\n     */\n    public stopPropagationHint: boolean;\n\n    /**\n     * The object which caused this event to be dispatched.\n     * For listener callback see {@link PIXI.InteractionEvent.currentTarget}.\n     */\n    public target: DisplayObject;\n\n    /** The object whose event listener’s callback is currently being invoked. */\n    public currentTarget: DisplayObject;\n\n    /** Type of the event. */\n    public type: string;\n\n    /** {@link InteractionData} related to this event */\n    public data: InteractionData;\n\n    constructor()\n    {\n        this.stopped = false;\n        this.stopsPropagatingAt = null;\n        this.stopPropagationHint = false;\n        this.target = null;\n        this.currentTarget = null;\n        this.type = null;\n        this.data = null;\n    }\n\n    /** Prevents event from reaching any objects other than the current object. */\n    public stopPropagation(): void\n    {\n        this.stopped = true;\n        this.stopPropagationHint = true;\n        this.stopsPropagatingAt = this.currentTarget;\n    }\n\n    /** Resets the event. */\n    public reset(): void\n    {\n        this.stopped = false;\n        this.stopsPropagatingAt = null;\n        this.stopPropagationHint = false;\n        this.currentTarget = null;\n        this.target = null;\n    }\n}\n","export interface InteractionTrackingFlags\n{\n    OVER: number;\n    LEFT_DOWN: number;\n    RIGHT_DOWN: number;\n    NONE: number;\n}\n\n/**\n * DisplayObjects with the {@link PIXI.interactiveTarget} mixin use this class to track interactions\n * @class\n * @private\n * @memberof PIXI\n */\nexport class InteractionTrackingData\n{\n    public static FLAGS: Readonly<InteractionTrackingFlags> = Object.freeze({\n        NONE: 0,\n        OVER: 1 << 0,\n        LEFT_DOWN: 1 << 1,\n        RIGHT_DOWN: 1 << 2,\n    });\n\n    private readonly _pointerId: number;\n    private _flags: number;\n\n    /**\n     * @param {number} pointerId - Unique pointer id of the event\n     * @private\n     */\n    constructor(pointerId: number)\n    {\n        this._pointerId = pointerId;\n        this._flags = InteractionTrackingData.FLAGS.NONE;\n    }\n\n    /**\n     *\n     * @private\n     * @param {number} flag - The interaction flag to set\n     * @param {boolean} yn - Should the flag be set or unset\n     */\n    private _doSet(flag: number, yn: boolean): void\n    {\n        if (yn)\n        {\n            this._flags = this._flags | flag;\n        }\n        else\n        {\n            this._flags = this._flags & (~flag);\n        }\n    }\n\n    /**\n     * Unique pointer id of the event\n     * @readonly\n     * @private\n     * @member {number}\n     */\n    get pointerId(): number\n    {\n        return this._pointerId;\n    }\n\n    /**\n     * State of the tracking data, expressed as bit flags\n     * @private\n     * @member {number}\n     */\n    get flags(): number\n    {\n        return this._flags;\n    }\n\n    set flags(flags: number)\n    {\n        this._flags = flags;\n    }\n\n    /**\n     * Is the tracked event inactive (not over or down)?\n     * @private\n     * @member {number}\n     */\n    get none(): boolean\n    {\n        return this._flags === InteractionTrackingData.FLAGS.NONE;\n    }\n\n    /**\n     * Is the tracked event over the DisplayObject?\n     * @private\n     * @member {boolean}\n     */\n    get over(): boolean\n    {\n        return (this._flags & InteractionTrackingData.FLAGS.OVER) !== 0;\n    }\n\n    set over(yn: boolean)\n    {\n        this._doSet(InteractionTrackingData.FLAGS.OVER, yn);\n    }\n\n    /**\n     * Did the right mouse button come down in the DisplayObject?\n     * @private\n     * @member {boolean}\n     */\n    get rightDown(): boolean\n    {\n        return (this._flags & InteractionTrackingData.FLAGS.RIGHT_DOWN) !== 0;\n    }\n\n    set rightDown(yn: boolean)\n    {\n        this._doSet(InteractionTrackingData.FLAGS.RIGHT_DOWN, yn);\n    }\n\n    /**\n     * Did the left mouse button come down in the DisplayObject?\n     * @private\n     * @member {boolean}\n     */\n    get leftDown(): boolean\n    {\n        return (this._flags & InteractionTrackingData.FLAGS.LEFT_DOWN) !== 0;\n    }\n\n    set leftDown(yn: boolean)\n    {\n        this._doSet(InteractionTrackingData.FLAGS.LEFT_DOWN, yn);\n    }\n}\n","import { Point } from '@pixi/math';\n\nimport type { InteractionEvent, InteractionCallback } from './InteractionEvent';\nimport type { Container, DisplayObject } from '@pixi/display';\n\n/**\n * Strategy how to search through stage tree for interactive objects\n * @memberof PIXI\n */\nexport class TreeSearch\n{\n    private readonly _tempPoint: Point;\n\n    constructor()\n    {\n        this._tempPoint = new Point();\n    }\n\n    /**\n     * Recursive implementation for findHit\n     * @private\n     * @param interactionEvent - event containing the point that\n     *  is tested for collision\n     * @param displayObject - the displayObject\n     *  that will be hit test (recursively crawls its children)\n     * @param func - the function that will be called on each interactive object. The\n     *  interactionEvent, displayObject and hit will be passed to the function\n     * @param hitTest - this indicates if the objects inside should be hit test against the point\n     * @param interactive - Whether the displayObject is interactive\n     * @returns - Returns true if the displayObject hit the point\n     */\n    public recursiveFindHit(interactionEvent: InteractionEvent, displayObject: DisplayObject,\n        func?: InteractionCallback, hitTest?: boolean, interactive?: boolean\n    ): boolean\n    {\n        if (!displayObject || !displayObject.visible)\n        {\n            return false;\n        }\n\n        const point = interactionEvent.data.global;\n\n        // Took a little while to rework this function correctly! But now it is done and nice and optimized! ^_^\n        //\n        // This function will now loop through all objects and then only hit test the objects it HAS\n        // to, not all of them. MUCH faster..\n        // An object will be hit test if the following is true:\n        //\n        // 1: It is interactive.\n        // 2: It belongs to a parent that is interactive AND one of the parents children have not already been hit.\n        //\n        // As another little optimization once an interactive object has been hit we can carry on\n        // through the scenegraph, but we know that there will be no more hits! So we can avoid extra hit tests\n        // A final optimization is that an object is not hit test directly if a child has already been hit.\n\n        interactive = displayObject.interactive || interactive;\n\n        let hit = false;\n        let interactiveParent = interactive;\n\n        // Flag here can set to false if the event is outside the parents hitArea or mask\n        let hitTestChildren = true;\n\n        // If there is a hitArea, no need to test against anything else if the pointer is not within the hitArea\n        // There is also no longer a need to hitTest children.\n        if (displayObject.hitArea)\n        {\n            if (hitTest)\n            {\n                displayObject.worldTransform.applyInverse(point, this._tempPoint);\n                if (!displayObject.hitArea.contains(this._tempPoint.x, this._tempPoint.y))\n                {\n                    hitTest = false;\n                    hitTestChildren = false;\n                }\n                else\n                {\n                    hit = true;\n                }\n            }\n            interactiveParent = false;\n        }\n        // If there is a mask, no need to hitTest against anything else if the pointer is not within the mask.\n        // We still want to hitTestChildren, however, to ensure a mouseout can still be generated.\n        // https://github.com/pixijs/pixi.js/issues/5135\n        else if (displayObject._mask)\n        {\n            if (hitTest)\n            {\n                const maskObject = ((displayObject._mask as any).isMaskData\n                    ? (displayObject._mask as any).maskObject : displayObject._mask) as any;\n\n                if (maskObject && !maskObject.containsPoint?.(point))\n                {\n                    hitTest = false;\n                }\n            }\n        }\n\n        // ** FREE TIP **! If an object is not interactive or has no buttons in it\n        // (such as a game scene!) set interactiveChildren to false for that displayObject.\n        // This will allow PixiJS to completely ignore and bypass checking the displayObjects children.\n        if (hitTestChildren && displayObject.interactiveChildren && (displayObject as Container).children)\n        {\n            const children = (displayObject as Container).children;\n\n            for (let i = children.length - 1; i >= 0; i--)\n            {\n                const child = children[i];\n\n                // time to get recursive.. if this function will return if something is hit..\n                const childHit = this.recursiveFindHit(interactionEvent, child, func, hitTest, interactiveParent);\n\n                if (childHit)\n                {\n                    // its a good idea to check if a child has lost its parent.\n                    // this means it has been removed whilst looping so its best\n                    if (!child.parent)\n                    {\n                        continue;\n                    }\n\n                    // we no longer need to hit test any more objects in this container as we we\n                    // now know the parent has been hit\n                    interactiveParent = false;\n\n                    // If the child is interactive , that means that the object hit was actually\n                    // interactive and not just the child of an interactive object.\n                    // This means we no longer need to hit test anything else. We still need to run\n                    // through all objects, but we don't need to perform any hit tests.\n\n                    if (childHit)\n                    {\n                        if (interactionEvent.target)\n                        {\n                            hitTest = false;\n                        }\n                        hit = true;\n                    }\n                }\n            }\n        }\n\n        // no point running this if the item is not interactive or does not have an interactive parent.\n        if (interactive)\n        {\n            // if we are hit testing (as in we have no hit any objects yet)\n            // We also don't need to worry about hit testing if once of the displayObjects children\n            // has already been hit - but only if it was interactive, otherwise we need to keep\n            // looking for an interactive child, just in case we hit one\n            if (hitTest && !interactionEvent.target)\n            {\n                // already tested against hitArea if it is defined\n                if (!displayObject.hitArea && (displayObject as any).containsPoint)\n                {\n                    if ((displayObject as any).containsPoint(point))\n                    {\n                        hit = true;\n                    }\n                }\n            }\n\n            if (displayObject.interactive)\n            {\n                if (hit && !interactionEvent.target)\n                {\n                    interactionEvent.target = displayObject;\n                }\n\n                if (func)\n                {\n                    func(interactionEvent, displayObject, !!hit);\n                }\n            }\n        }\n\n        return hit;\n    }\n\n    /**\n     * This function is provides a neat way of crawling through the scene graph and running a\n     * specified function on all interactive objects it finds. It will also take care of hit\n     * testing the interactive objects and passes the hit across in the function.\n     * @private\n     * @param interactionEvent - event containing the point that\n     *  is tested for collision\n     * @param displayObject - the displayObject\n     *  that will be hit test (recursively crawls its children)\n     * @param func - the function that will be called on each interactive object. The\n     *  interactionEvent, displayObject and hit will be passed to the function\n     * @param hitTest - this indicates if the objects inside should be hit test against the point\n     * @returns - Returns true if the displayObject hit the point\n     */\n    public findHit(interactionEvent: InteractionEvent, displayObject: DisplayObject,\n        func?: InteractionCallback, hitTest?: boolean\n    ): void\n    {\n        this.recursiveFindHit(interactionEvent, displayObject, func, hitTest, false);\n    }\n}\n","import type { InteractionTrackingData } from './InteractionTrackingData';\n\ntype Cursor = 'auto'\n| 'default'\n| 'none'\n| 'context-menu'\n| 'help'\n| 'pointer'\n| 'progress'\n| 'wait'\n| 'cell'\n| 'crosshair'\n| 'text'\n| 'vertical-text'\n| 'alias'\n| 'copy'\n| 'move'\n| 'no-drop'\n| 'not-allowed'\n| 'e-resize'\n| 'n-resize'\n| 'ne-resize'\n| 'nw-resize'\n| 's-resize'\n| 'se-resize'\n| 'sw-resize'\n| 'w-resize'\n| 'ns-resize'\n| 'ew-resize'\n| 'nesw-resize'\n| 'col-resize'\n| 'nwse-resize'\n| 'row-resize'\n| 'all-scroll'\n| 'zoom-in'\n| 'zoom-out'\n| 'grab'\n| 'grabbing';\n\nexport interface IHitArea\n{\n    contains(x: number, y: number): boolean;\n}\n\nexport interface InteractiveTarget\n{\n    interactive: boolean;\n    interactiveChildren: boolean;\n    hitArea: IHitArea | null;\n    cursor: Cursor | string;\n    buttonMode: boolean;\n    trackedPointers: {[x: number]: InteractionTrackingData};\n    _trackedPointers: {[x: number]: InteractionTrackingData};\n}\n\n/**\n * Interface for classes that represent a hit area.\n *\n * It is implemented by the following classes:\n * - {@link PIXI.Circle}\n * - {@link PIXI.Ellipse}\n * - {@link PIXI.Polygon}\n * - {@link PIXI.RoundedRectangle}\n * @interface IHitArea\n * @memberof PIXI\n */\n\n/**\n * Checks whether the x and y coordinates given are contained within this area\n * @method\n * @name contains\n * @memberof PIXI.IHitArea#\n * @param {number} x - The X coordinate of the point to test\n * @param {number} y - The Y coordinate of the point to test\n * @returns {boolean} Whether the x/y coordinates are within this area\n */\n\n/**\n * Default property values of interactive objects\n * Used by {@link PIXI.InteractionManager} to automatically give all DisplayObjects these properties\n * @private\n * @name interactiveTarget\n * @type {object}\n * @memberof PIXI\n * @example\n *      function MyObject() {}\n *\n *      Object.assign(\n *          DisplayObject.prototype,\n *          PIXI.interactiveTarget\n *      );\n */\nexport const interactiveTarget: InteractiveTarget = {\n    interactive: false,\n    interactiveChildren: true,\n    hitArea: null,\n\n    /**\n     * If enabled, the mouse cursor use the pointer behavior when hovered over the displayObject if it is interactive\n     * Setting this changes the 'cursor' property to `'pointer'`.\n     * @example\n     * const sprite = new PIXI.Sprite(texture);\n     * sprite.interactive = true;\n     * sprite.buttonMode = true;\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     */\n    get buttonMode(): boolean\n    {\n        return this.cursor === 'pointer';\n    },\n    set buttonMode(value: boolean)\n    {\n        if (value)\n        {\n            this.cursor = 'pointer';\n        }\n        else if (this.cursor === 'pointer')\n        {\n            this.cursor = null;\n        }\n    },\n\n    /**\n     * This defines what cursor mode is used when the mouse cursor\n     * is hovered over the displayObject.\n     * @example\n     * const sprite = new PIXI.Sprite(texture);\n     * sprite.interactive = true;\n     * sprite.cursor = 'wait';\n     * @see https://developer.mozilla.org/en/docs/Web/CSS/cursor\n     * @member {string}\n     * @memberof PIXI.DisplayObject#\n     */\n    cursor: null,\n\n    /**\n     * Internal set of all active pointers, by identifier\n     * @member {Map<number, InteractionTrackingData>}\n     * @memberof PIXI.DisplayObject#\n     * @private\n     */\n    get trackedPointers()\n    {\n        if (this._trackedPointers === undefined) this._trackedPointers = {};\n\n        return this._trackedPointers;\n    },\n\n    /**\n     * Map of all tracked pointers, by identifier. Use trackedPointers to access.\n     * @private\n     * @type {Map<number, InteractionTrackingData>}\n     */\n    _trackedPointers: undefined,\n};\n","import { Ticker, UPDATE_PRIORITY } from '@pixi/ticker';\nimport { DisplayObject, TemporaryDisplayObject } from '@pixi/display';\nimport type { InteractivePointerEvent } from './InteractionData';\nimport { InteractionData } from './InteractionData';\nimport type { InteractionCallback } from './InteractionEvent';\nimport { InteractionEvent } from './InteractionEvent';\nimport { InteractionTrackingData } from './InteractionTrackingData';\nimport { TreeSearch } from './TreeSearch';\nimport { EventEmitter } from '@pixi/utils';\nimport { interactiveTarget } from './interactiveTarget';\n\nimport type { AbstractRenderer, ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\nimport type { Point, IPointData } from '@pixi/math';\nimport type { Dict } from '@pixi/utils';\n\n// Mix interactiveTarget into DisplayObject.prototype\nDisplayObject.mixin(interactiveTarget);\n\nconst MOUSE_POINTER_ID = 1;\n\n// Mock interface for hitTestEvent - only used inside hitTest()\ninterface TestInteractionEvent\n{\n    target: DisplayObject;\n    data: {global: Point};\n}\n\n// helpers for hitTest() - only used inside hitTest()\nconst hitTestEvent: TestInteractionEvent = {\n    target: null,\n    data: {\n        global: null,\n    },\n};\n\nexport interface InteractionManagerOptions\n{\n    autoPreventDefault?: boolean;\n    interactionFrequency?: number;\n    useSystemTicker?: boolean;\n}\n\nexport interface DelayedEvent\n{\n    displayObject: DisplayObject;\n    eventString: string;\n    eventData: InteractionEvent;\n}\n\ninterface CrossCSSStyleDeclaration extends CSSStyleDeclaration\n{\n    msContentZooming: string;\n    msTouchAction: string;\n}\n\n/**\n * The interaction manager deals with mouse, touch and pointer events.\n *\n * Any DisplayObject can be interactive if its `interactive` property is set to true.\n *\n * This manager also supports multitouch.\n *\n * An instance of this class is automatically created by default, and can be found at `renderer.plugins.interaction`\n * @memberof PIXI\n */\nexport class InteractionManager extends EventEmitter\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'interaction',\n        type: [\n            ExtensionType.RendererPlugin,\n            ExtensionType.CanvasRendererPlugin,\n        ],\n    };\n\n    /**\n     * Actively tracked InteractionData\n     * @private\n     * @member {Object<number, PIXI.InteractionData>}\n     */\n    public readonly activeInteractionData: { [key: number]: InteractionData };\n\n    /** Does the device support touch events https://www.w3.org/TR/touch-events/ */\n    public readonly supportsTouchEvents: boolean;\n\n    /** Does the device support pointer events https://www.w3.org/Submission/pointer-events/ */\n    public readonly supportsPointerEvents: boolean;\n\n    /**\n     * Pool of unused InteractionData\n     * @private\n     */\n    public interactionDataPool: InteractionData[];\n\n    /**\n     * Internal cached let.\n     * @private\n     */\n    public cursor: string;\n\n    /**\n     * Delayed pointer events. Used to guarantee correct ordering of over/out events.\n     * @private\n     */\n    public delayedEvents: DelayedEvent[];\n\n    /**\n     * TreeSearch component that is used to hitTest stage tree.\n     * @private\n     */\n    public search: TreeSearch;\n\n    /** The renderer this interaction manager works for. */\n    public renderer: AbstractRenderer;\n\n    /**\n     * Should default browser actions automatically be prevented.\n     * Does not apply to pointer events for backwards compatibility as\n     * preventDefault on pointer events stops mouse events from firing.\n     * Thus, for every pointer event, there will always be either a mouse of touch event alongside it.\n     * @default true\n     */\n    public autoPreventDefault: boolean;\n\n    /**\n     * Maximum frequency in milliseconds at which pointer over/out states will be checked by {@link tickerUpdate}.\n     * @default 10\n     */\n    public interactionFrequency: number;\n\n    /** The mouse data. */\n    public mouse: InteractionData;\n\n    /** An event data object to handle all the event tracking/dispatching. */\n    public eventData: InteractionEvent;\n\n    /**\n     * This property determines if mousemove and touchmove events are fired only when the cursor\n     * is over the object.\n     * Setting to true will make things work more in line with how the DOM version works.\n     * Setting to false can make things easier for things like dragging\n     * It is currently set to false as this is how PixiJS used to work. This will be set to true in\n     * future versions of pixi.\n     * @default false\n     */\n    public moveWhenInside: boolean;\n\n    /**\n     * Dictionary of how different cursor modes are handled. Strings are handled as CSS cursor\n     * values, objects are handled as dictionaries of CSS values for interactionDOMElement,\n     * and functions are called instead of changing the CSS.\n     * Default CSS cursor values are provided for 'default' and 'pointer' modes.\n     * @member {Object<string, Object>}\n     */\n    public cursorStyles: Dict<string | ((mode: string) => void) | CSSStyleDeclaration>;\n\n    /** The mode of the cursor that is being used. The value of this is a key from the cursorStyles dictionary. */\n    public currentCursorMode: string;\n\n    /**\n     * The current resolution / device pixel ratio.\n     * @default 1\n     */\n    public resolution: number;\n\n    /** The DOM element to bind to. */\n    protected interactionDOMElement: HTMLElement;\n\n    /** Have events been attached to the dom element? */\n    protected eventsAdded: boolean;\n\n    /** Has the system ticker been added? */\n    protected tickerAdded: boolean;\n\n    /** Is the mouse hovering over the renderer? If working in worker mouse considered to be over renderer by default. */\n    protected mouseOverRenderer: boolean;\n\n    private _useSystemTicker: boolean;\n    private _deltaTime: number;\n    private _didMove: boolean;\n\n    /** Used as a last rendered object in case renderer doesnt have _lastObjectRendered. */\n    private _tempDisplayObject: DisplayObject;\n\n    /**\n     * An options object specifies characteristics about the event listener.\n     * @member {Object<string, boolean>}\n     */\n    private readonly _eventListenerOptions: { capture: true, passive: false };\n\n    /**\n     * @param {PIXI.CanvasRenderer|PIXI.Renderer} renderer - A reference to the current renderer\n     * @param options - The options for the manager.\n     * @param {boolean} [options.autoPreventDefault=true] - Should the manager automatically prevent default browser actions.\n     * @param {number} [options.interactionFrequency=10] - Maximum frequency (ms) at pointer over/out states will be checked.\n     * @param {number} [options.useSystemTicker=true] - Whether to add {@link tickerUpdate} to {@link PIXI.Ticker.system}.\n     */\n    constructor(renderer: AbstractRenderer, options?: InteractionManagerOptions)\n    {\n        super();\n\n        options = options || {};\n\n        this.renderer = renderer;\n        this.autoPreventDefault = options.autoPreventDefault !== undefined ? options.autoPreventDefault : true;\n        this.interactionFrequency = options.interactionFrequency || 10;\n        this.mouse = new InteractionData();\n        this.mouse.identifier = MOUSE_POINTER_ID;\n\n        // setting the mouse to start off far off screen will mean that mouse over does\n        //  not get called before we even move the mouse.\n        this.mouse.global.set(-999999);\n\n        this.activeInteractionData = {};\n        this.activeInteractionData[MOUSE_POINTER_ID] = this.mouse;\n        this.interactionDataPool = [];\n        this.eventData = new InteractionEvent();\n        this.interactionDOMElement = null;\n\n        this.moveWhenInside = false;\n        this.eventsAdded = false;\n        this.tickerAdded = false;\n        this.mouseOverRenderer = !('PointerEvent' in globalThis);\n        this.supportsTouchEvents = 'ontouchstart' in globalThis;\n        this.supportsPointerEvents = !!globalThis.PointerEvent;\n\n        // this will make it so that you don't have to call bind all the time\n\n        this.onPointerUp = this.onPointerUp.bind(this);\n        this.processPointerUp = this.processPointerUp.bind(this);\n\n        this.onPointerCancel = this.onPointerCancel.bind(this);\n        this.processPointerCancel = this.processPointerCancel.bind(this);\n\n        this.onPointerDown = this.onPointerDown.bind(this);\n        this.processPointerDown = this.processPointerDown.bind(this);\n\n        this.onPointerMove = this.onPointerMove.bind(this);\n        this.processPointerMove = this.processPointerMove.bind(this);\n\n        this.onPointerOut = this.onPointerOut.bind(this);\n        this.processPointerOverOut = this.processPointerOverOut.bind(this);\n\n        this.onPointerOver = this.onPointerOver.bind(this);\n\n        this.cursorStyles = {\n            default: 'inherit',\n            pointer: 'pointer',\n        };\n        this.currentCursorMode = null;\n        this.cursor = null;\n\n        this.resolution = 1;\n        this.delayedEvents = [];\n        this.search = new TreeSearch();\n\n        this._tempDisplayObject = new TemporaryDisplayObject();\n        this._eventListenerOptions = { capture: true, passive: false };\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is pressed on the display\n         * object.\n         * @event PIXI.InteractionManager#mousedown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed\n         * on the display object.\n         * @event PIXI.InteractionManager#rightdown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is released over the display\n         * object.\n         * @event PIXI.InteractionManager#mouseup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is released\n         * over the display object.\n         * @event PIXI.InteractionManager#rightup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is pressed and released on\n         * the display object.\n         * @event PIXI.InteractionManager#click\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed\n         * and released on the display object.\n         * @event PIXI.InteractionManager#rightclick\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is released outside the\n         * display object that initially registered a\n         * [mousedown]{@link PIXI.InteractionManager#event:mousedown}.\n         * @event PIXI.InteractionManager#mouseupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is released\n         * outside the display object that initially registered a\n         * [rightdown]{@link PIXI.InteractionManager#event:rightdown}.\n         * @event PIXI.InteractionManager#rightupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved while over the display object\n         * @event PIXI.InteractionManager#mousemove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved onto the display object\n         * @event PIXI.InteractionManager#mouseover\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved off the display object\n         * @event PIXI.InteractionManager#mouseout\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is pressed on the display object.\n         * @event PIXI.InteractionManager#pointerdown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is released over the display object.\n         * Not always fired when some buttons are held down while others are released. In those cases,\n         * use [mousedown]{@link PIXI.InteractionManager#event:mousedown} and\n         * [mouseup]{@link PIXI.InteractionManager#event:mouseup} instead.\n         * @event PIXI.InteractionManager#pointerup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when the operating system cancels a pointer event\n         * @event PIXI.InteractionManager#pointercancel\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is pressed and released on the display object.\n         * @event PIXI.InteractionManager#pointertap\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is released outside the display object that initially\n         * registered a [pointerdown]{@link PIXI.InteractionManager#event:pointerdown}.\n         * @event PIXI.InteractionManager#pointerupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved while over the display object\n         * @event PIXI.InteractionManager#pointermove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved onto the display object\n         * @event PIXI.InteractionManager#pointerover\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved off the display object\n         * @event PIXI.InteractionManager#pointerout\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is placed on the display object.\n         * @event PIXI.InteractionManager#touchstart\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is removed from the display object.\n         * @event PIXI.InteractionManager#touchend\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when the operating system cancels a touch\n         * @event PIXI.InteractionManager#touchcancel\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is placed and removed from the display object.\n         * @event PIXI.InteractionManager#tap\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is removed outside of the display object that initially\n         * registered a [touchstart]{@link PIXI.InteractionManager#event:touchstart}.\n         * @event PIXI.InteractionManager#touchendoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is moved along the display object.\n         * @event PIXI.InteractionManager#touchmove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is pressed on the display.\n         * object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mousedown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed\n         * on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#rightdown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is released over the display\n         * object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mouseup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is released\n         * over the display object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#rightup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is pressed and released on\n         * the display object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#click\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is pressed\n         * and released on the display object. DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#rightclick\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button (usually a mouse left-button) is released outside the\n         * display object that initially registered a\n         * [mousedown]{@link PIXI.DisplayObject#event:mousedown}.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mouseupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device secondary button (usually a mouse right-button) is released\n         * outside the display object that initially registered a\n         * [rightdown]{@link PIXI.DisplayObject#event:rightdown}.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#rightupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved while over the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mousemove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved onto the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mouseover\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device (usually a mouse) is moved off the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#mouseout\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is pressed on the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointerdown\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is released over the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointerup\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when the operating system cancels a pointer event.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointercancel\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is pressed and released on the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointertap\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device button is released outside the display object that initially\n         * registered a [pointerdown]{@link PIXI.DisplayObject#event:pointerdown}.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointerupoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved while over the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointermove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved onto the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointerover\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a pointer device is moved off the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#pointerout\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is placed on the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#touchstart\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is removed from the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#touchend\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when the operating system cancels a touch.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#touchcancel\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is placed and removed from the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#tap\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is removed outside of the display object that initially\n         * registered a [touchstart]{@link PIXI.DisplayObject#event:touchstart}.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#touchendoutside\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        /**\n         * Fired when a touch point is moved along the display object.\n         * DisplayObject's `interactive` property must be set to `true` to fire event.\n         *\n         * This comes from the @pixi/interaction package.\n         * @event PIXI.DisplayObject#touchmove\n         * @param {PIXI.InteractionEvent} event - Interaction event\n         */\n\n        this._useSystemTicker = options.useSystemTicker !== undefined ? options.useSystemTicker : true;\n\n        this.setTargetElement(this.renderer.view, this.renderer.resolution);\n    }\n\n    /**\n     * Should the InteractionManager automatically add {@link tickerUpdate} to {@link PIXI.Ticker.system}.\n     * @default true\n     */\n    get useSystemTicker(): boolean\n    {\n        return this._useSystemTicker;\n    }\n    set useSystemTicker(useSystemTicker: boolean)\n    {\n        this._useSystemTicker = useSystemTicker;\n\n        if (useSystemTicker)\n        {\n            this.addTickerListener();\n        }\n        else\n        {\n            this.removeTickerListener();\n        }\n    }\n\n    /**\n     * Last rendered object or temp object.\n     * @readonly\n     * @protected\n     */\n    get lastObjectRendered(): DisplayObject\n    {\n        return (this.renderer._lastObjectRendered as DisplayObject) || this._tempDisplayObject;\n    }\n\n    /**\n     * Hit tests a point against the display tree, returning the first interactive object that is hit.\n     * @param globalPoint - A point to hit test with, in global space.\n     * @param root - The root display object to start from. If omitted, defaults\n     * to the last rendered root of the associated renderer.\n     * @returns - The hit display object, if any.\n     */\n    public hitTest(globalPoint: Point, root?: DisplayObject): DisplayObject\n    {\n        // clear the target for our hit test\n        hitTestEvent.target = null;\n        // assign the global point\n        hitTestEvent.data.global = globalPoint;\n        // ensure safety of the root\n        if (!root)\n        {\n            root = this.lastObjectRendered;\n        }\n        // run the hit test\n        this.processInteractive(hitTestEvent as InteractionEvent, root, null, true);\n        // return our found object - it'll be null if we didn't hit anything\n\n        return hitTestEvent.target;\n    }\n\n    /**\n     * Sets the DOM element which will receive mouse/touch events. This is useful for when you have\n     * other DOM elements on top of the renderers Canvas element. With this you'll be bale to delegate\n     * another DOM element to receive those events.\n     * @param element - the DOM element which will receive mouse and touch events.\n     * @param resolution - The resolution / device pixel ratio of the new element (relative to the canvas).\n     */\n    public setTargetElement(element: HTMLElement, resolution = 1): void\n    {\n        this.removeTickerListener();\n\n        this.removeEvents();\n\n        this.interactionDOMElement = element;\n\n        this.resolution = resolution;\n\n        this.addEvents();\n\n        this.addTickerListener();\n    }\n\n    /** Adds the ticker listener. */\n    private addTickerListener(): void\n    {\n        if (this.tickerAdded || !this.interactionDOMElement || !this._useSystemTicker)\n        {\n            return;\n        }\n\n        Ticker.system.add(this.tickerUpdate, this, UPDATE_PRIORITY.INTERACTION);\n\n        this.tickerAdded = true;\n    }\n\n    /** Removes the ticker listener. */\n    private removeTickerListener(): void\n    {\n        if (!this.tickerAdded)\n        {\n            return;\n        }\n\n        Ticker.system.remove(this.tickerUpdate, this);\n\n        this.tickerAdded = false;\n    }\n\n    /** Registers all the DOM events. */\n    private addEvents(): void\n    {\n        if (this.eventsAdded || !this.interactionDOMElement)\n        {\n            return;\n        }\n\n        const style = this.interactionDOMElement.style as CrossCSSStyleDeclaration;\n\n        if ((globalThis.navigator as any).msPointerEnabled)\n        {\n            style.msContentZooming = 'none';\n            style.msTouchAction = 'none';\n        }\n        else if (this.supportsPointerEvents)\n        {\n            style.touchAction = 'none';\n        }\n\n        /*\n         * These events are added first, so that if pointer events are normalized, they are fired\n         * in the same order as non-normalized events. ie. pointer event 1st, mouse / touch 2nd\n         */\n        if (this.supportsPointerEvents)\n        {\n            globalThis.document.addEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);\n            // pointerout is fired in addition to pointerup (for touch events) and pointercancel\n            // we already handle those, so for the purposes of what we do in onPointerOut, we only\n            // care about the pointerleave event\n            this.interactionDOMElement.addEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);\n            globalThis.addEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);\n            globalThis.addEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);\n        }\n        else\n        {\n            globalThis.document.addEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);\n            globalThis.addEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);\n        }\n\n        // always look directly for touch events so that we can provide original data\n        // In a future version we should change this to being just a fallback and rely solely on\n        // PointerEvents whenever available\n        if (this.supportsTouchEvents)\n        {\n            this.interactionDOMElement.addEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('touchend', this.onPointerUp, this._eventListenerOptions);\n            this.interactionDOMElement.addEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);\n        }\n\n        this.eventsAdded = true;\n    }\n\n    /** Removes all the DOM events that were previously registered. */\n    private removeEvents(): void\n    {\n        if (!this.eventsAdded || !this.interactionDOMElement)\n        {\n            return;\n        }\n\n        const style = this.interactionDOMElement.style as CrossCSSStyleDeclaration;\n\n        if ((globalThis.navigator as any).msPointerEnabled)\n        {\n            style.msContentZooming = '';\n            style.msTouchAction = '';\n        }\n        else if (this.supportsPointerEvents)\n        {\n            style.touchAction = '';\n        }\n\n        if (this.supportsPointerEvents)\n        {\n            globalThis.document.removeEventListener('pointermove', this.onPointerMove, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('pointerdown', this.onPointerDown, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('pointerleave', this.onPointerOut, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('pointerover', this.onPointerOver, this._eventListenerOptions);\n            globalThis.removeEventListener('pointercancel', this.onPointerCancel, this._eventListenerOptions);\n            globalThis.removeEventListener('pointerup', this.onPointerUp, this._eventListenerOptions);\n        }\n        else\n        {\n            globalThis.document.removeEventListener('mousemove', this.onPointerMove, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('mousedown', this.onPointerDown, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('mouseout', this.onPointerOut, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('mouseover', this.onPointerOver, this._eventListenerOptions);\n            globalThis.removeEventListener('mouseup', this.onPointerUp, this._eventListenerOptions);\n        }\n\n        if (this.supportsTouchEvents)\n        {\n            this.interactionDOMElement.removeEventListener('touchstart', this.onPointerDown, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('touchcancel', this.onPointerCancel, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('touchend', this.onPointerUp, this._eventListenerOptions);\n            this.interactionDOMElement.removeEventListener('touchmove', this.onPointerMove, this._eventListenerOptions);\n        }\n\n        this.interactionDOMElement = null;\n\n        this.eventsAdded = false;\n    }\n\n    /**\n     * Updates the state of interactive objects if at least {@link interactionFrequency}\n     * milliseconds have passed since the last invocation.\n     *\n     * Invoked by a throttled ticker update from {@link PIXI.Ticker.system}.\n     * @param deltaTime - time delta since the last call\n     */\n    public tickerUpdate(deltaTime: number): void\n    {\n        this._deltaTime += deltaTime;\n\n        if (this._deltaTime < this.interactionFrequency)\n        {\n            return;\n        }\n\n        this._deltaTime = 0;\n\n        this.update();\n    }\n\n    /** Updates the state of interactive objects. */\n    public update(): void\n    {\n        if (!this.interactionDOMElement)\n        {\n            return;\n        }\n\n        // if the user move the mouse this check has already been done using the mouse move!\n        if (this._didMove)\n        {\n            this._didMove = false;\n\n            return;\n        }\n\n        this.cursor = null;\n\n        // Resets the flag as set by a stopPropagation call. This flag is usually reset by a user interaction of any kind,\n        // but there was a scenario of a display object moving under a static mouse cursor.\n        // In this case, mouseover and mouseevents would not pass the flag test in dispatchEvent function\n        for (const k in this.activeInteractionData)\n        {\n            // eslint-disable-next-line no-prototype-builtins\n            if (this.activeInteractionData.hasOwnProperty(k))\n            {\n                const interactionData = this.activeInteractionData[k];\n\n                if (interactionData.originalEvent && interactionData.pointerType !== 'touch')\n                {\n                    const interactionEvent = this.configureInteractionEventForDOMEvent(\n                        this.eventData,\n                        interactionData.originalEvent as PointerEvent,\n                        interactionData\n                    );\n\n                    this.processInteractive(\n                        interactionEvent,\n                        this.lastObjectRendered,\n                        this.processPointerOverOut,\n                        true\n                    );\n                }\n            }\n        }\n\n        this.setCursorMode(this.cursor);\n    }\n\n    /**\n     * Sets the current cursor mode, handling any callbacks or CSS style changes.\n     * @param mode - cursor mode, a key from the cursorStyles dictionary\n     */\n    public setCursorMode(mode: string): void\n    {\n        mode = mode || 'default';\n        let applyStyles = true;\n\n        // offscreen canvas does not support setting styles, but cursor modes can be functions,\n        // in order to handle pixi rendered cursors, so we can't bail\n        if (globalThis.OffscreenCanvas && this.interactionDOMElement instanceof OffscreenCanvas)\n        {\n            applyStyles = false;\n        }\n        // if the mode didn't actually change, bail early\n        if (this.currentCursorMode === mode)\n        {\n            return;\n        }\n        this.currentCursorMode = mode;\n        const style = this.cursorStyles[mode];\n\n        // only do things if there is a cursor style for it\n        if (style)\n        {\n            switch (typeof style)\n            {\n                case 'string':\n                    // string styles are handled as cursor CSS\n                    if (applyStyles)\n                    {\n                        this.interactionDOMElement.style.cursor = style;\n                    }\n                    break;\n                case 'function':\n                    // functions are just called, and passed the cursor mode\n                    style(mode);\n                    break;\n                case 'object':\n                    // if it is an object, assume that it is a dictionary of CSS styles,\n                    // apply it to the interactionDOMElement\n                    if (applyStyles)\n                    {\n                        Object.assign(this.interactionDOMElement.style, style);\n                    }\n                    break;\n            }\n        }\n        else if (applyStyles && typeof mode === 'string' && !Object.prototype.hasOwnProperty.call(this.cursorStyles, mode))\n        {\n            // if it mode is a string (not a Symbol) and cursorStyles doesn't have any entry\n            // for the mode, then assume that the dev wants it to be CSS for the cursor.\n            this.interactionDOMElement.style.cursor = mode;\n        }\n    }\n\n    /**\n     * Dispatches an event on the display object that was interacted with.\n     * @param displayObject - the display object in question\n     * @param eventString - the name of the event (e.g, mousedown)\n     * @param eventData - the event data object\n     */\n    private dispatchEvent(displayObject: DisplayObject, eventString: string, eventData: InteractionEvent): void\n    {\n        // Even if the event was stopped, at least dispatch any remaining events\n        // for the same display object.\n        if (!eventData.stopPropagationHint || displayObject === eventData.stopsPropagatingAt)\n        {\n            eventData.currentTarget = displayObject;\n            eventData.type = eventString;\n\n            displayObject.emit(eventString, eventData);\n\n            if ((displayObject as any)[eventString])\n            {\n                (displayObject as any)[eventString](eventData);\n            }\n        }\n    }\n\n    /**\n     * Puts a event on a queue to be dispatched later. This is used to guarantee correct\n     * ordering of over/out events.\n     * @param displayObject - the display object in question\n     * @param eventString - the name of the event (e.g, mousedown)\n     * @param eventData - the event data object\n     */\n    private delayDispatchEvent(displayObject: DisplayObject, eventString: string, eventData: InteractionEvent): void\n    {\n        this.delayedEvents.push({ displayObject, eventString, eventData });\n    }\n\n    /**\n     * Maps x and y coords from a DOM object and maps them correctly to the PixiJS view. The\n     * resulting value is stored in the point. This takes into account the fact that the DOM\n     * element could be scaled and positioned anywhere on the screen.\n     * @param point - the point that the result will be stored in\n     * @param x - the x coord of the position to map\n     * @param y - the y coord of the position to map\n     */\n    public mapPositionToPoint(point: IPointData, x: number, y: number): void\n    {\n        let rect;\n\n        // IE 11 fix\n        if (!this.interactionDOMElement.parentElement)\n        {\n            rect = {\n                x: 0,\n                y: 0,\n                width: (this.interactionDOMElement as any).width,\n                height: (this.interactionDOMElement as any).height,\n                left: 0,\n                top: 0\n            };\n        }\n        else\n        {\n            rect = this.interactionDOMElement.getBoundingClientRect();\n        }\n\n        const resolutionMultiplier = 1.0 / this.resolution;\n\n        point.x = ((x - rect.left) * ((this.interactionDOMElement as any).width / rect.width)) * resolutionMultiplier;\n        point.y = ((y - rect.top) * ((this.interactionDOMElement as any).height / rect.height)) * resolutionMultiplier;\n    }\n\n    /**\n     * This function is provides a neat way of crawling through the scene graph and running a\n     * specified function on all interactive objects it finds. It will also take care of hit\n     * testing the interactive objects and passes the hit across in the function.\n     * @protected\n     * @param interactionEvent - event containing the point that\n     *  is tested for collision\n     * @param displayObject - the displayObject\n     *  that will be hit test (recursively crawls its children)\n     * @param func - the function that will be called on each interactive object. The\n     *  interactionEvent, displayObject and hit will be passed to the function\n     * @param hitTest - indicates whether we want to calculate hits\n     *  or just iterate through all interactive objects\n     */\n    public processInteractive(interactionEvent: InteractionEvent, displayObject: DisplayObject,\n        func?: InteractionCallback, hitTest?: boolean\n    ): void\n    {\n        const hit = this.search.findHit(interactionEvent, displayObject, func, hitTest);\n\n        const delayedEvents = this.delayedEvents;\n\n        if (!delayedEvents.length)\n        {\n            return hit;\n        }\n        // Reset the propagation hint, because we start deeper in the tree again.\n        interactionEvent.stopPropagationHint = false;\n\n        const delayedLen = delayedEvents.length;\n\n        this.delayedEvents = [];\n\n        for (let i = 0; i < delayedLen; i++)\n        {\n            const { displayObject, eventString, eventData } = delayedEvents[i];\n\n            // When we reach the object we wanted to stop propagating at,\n            // set the propagation hint.\n            if (eventData.stopsPropagatingAt === displayObject)\n            {\n                eventData.stopPropagationHint = true;\n            }\n\n            this.dispatchEvent(displayObject, eventString, eventData);\n        }\n\n        return hit;\n    }\n\n    /**\n     * Is called when the pointer button is pressed down on the renderer element\n     * @param originalEvent - The DOM event of a pointer button being pressed down\n     */\n    private onPointerDown(originalEvent: InteractivePointerEvent): void\n    {\n        // if we support touch events, then only use those for touch events, not pointer events\n        if (this.supportsTouchEvents && (originalEvent as PointerEvent).pointerType === 'touch') return;\n\n        const events = this.normalizeToPointerData(originalEvent);\n\n        /*\n         * No need to prevent default on natural pointer events, as there are no side effects\n         * Normalized events, however, may have the double mousedown/touchstart issue on the native android browser,\n         * so still need to be prevented.\n         */\n\n        // Guaranteed that there will be at least one event in events, and all events must have the same pointer type\n\n        if (this.autoPreventDefault && (events[0] as any).isNormalized)\n        {\n            const cancelable = originalEvent.cancelable || !('cancelable' in originalEvent);\n\n            if (cancelable)\n            {\n                originalEvent.preventDefault();\n            }\n        }\n\n        const eventLen = events.length;\n\n        for (let i = 0; i < eventLen; i++)\n        {\n            const event = events[i];\n\n            const interactionData = this.getInteractionDataForPointerId(event);\n\n            const interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);\n\n            interactionEvent.data.originalEvent = originalEvent;\n\n            this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerDown, true);\n\n            this.emit('pointerdown', interactionEvent);\n            if (event.pointerType === 'touch')\n            {\n                this.emit('touchstart', interactionEvent);\n            }\n            // emit a mouse event for \"pen\" pointers, the way a browser would emit a fallback event\n            else if (event.pointerType === 'mouse' || event.pointerType === 'pen')\n            {\n                const isRightButton = event.button === 2;\n\n                this.emit(isRightButton ? 'rightdown' : 'mousedown', this.eventData);\n            }\n        }\n    }\n\n    /**\n     * Processes the result of the pointer down check and dispatches the event if need be\n     * @param interactionEvent - The interaction event wrapping the DOM event\n     * @param displayObject - The display object that was tested\n     * @param hit - the result of the hit test on the display object\n     */\n    private processPointerDown(interactionEvent: InteractionEvent, displayObject: DisplayObject, hit: boolean): void\n    {\n        const data = interactionEvent.data;\n        const id = interactionEvent.data.identifier;\n\n        if (hit)\n        {\n            if (!displayObject.trackedPointers[id])\n            {\n                displayObject.trackedPointers[id] = new InteractionTrackingData(id);\n            }\n            this.dispatchEvent(displayObject, 'pointerdown', interactionEvent);\n\n            if (data.pointerType === 'touch')\n            {\n                this.dispatchEvent(displayObject, 'touchstart', interactionEvent);\n            }\n            else if (data.pointerType === 'mouse' || data.pointerType === 'pen')\n            {\n                const isRightButton = data.button === 2;\n\n                if (isRightButton)\n                {\n                    displayObject.trackedPointers[id].rightDown = true;\n                }\n                else\n                {\n                    displayObject.trackedPointers[id].leftDown = true;\n                }\n\n                this.dispatchEvent(displayObject, isRightButton ? 'rightdown' : 'mousedown', interactionEvent);\n            }\n        }\n    }\n\n    /**\n     * Is called when the pointer button is released on the renderer element\n     * @param originalEvent - The DOM event of a pointer button being released\n     * @param cancelled - true if the pointer is cancelled\n     * @param func - Function passed to {@link processInteractive}\n     */\n    private onPointerComplete(originalEvent: InteractivePointerEvent, cancelled: boolean, func: InteractionCallback): void\n    {\n        const events = this.normalizeToPointerData(originalEvent);\n\n        const eventLen = events.length;\n\n        // if the event wasn't targeting our canvas, then consider it to be pointerupoutside\n        // in all cases (unless it was a pointercancel)\n        let target = originalEvent.target;\n\n        // if in shadow DOM use composedPath to access target\n        if (originalEvent.composedPath && originalEvent.composedPath().length > 0)\n        {\n            target = originalEvent.composedPath()[0];\n        }\n\n        const eventAppend = target !== this.interactionDOMElement ? 'outside' : '';\n\n        for (let i = 0; i < eventLen; i++)\n        {\n            const event = events[i];\n\n            const interactionData = this.getInteractionDataForPointerId(event);\n\n            const interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);\n\n            interactionEvent.data.originalEvent = originalEvent;\n\n            // perform hit testing for events targeting our canvas or cancel events\n            this.processInteractive(interactionEvent, this.lastObjectRendered, func, cancelled || !eventAppend);\n\n            this.emit(cancelled ? 'pointercancel' : `pointerup${eventAppend}`, interactionEvent);\n\n            if (event.pointerType === 'mouse' || event.pointerType === 'pen')\n            {\n                const isRightButton = event.button === 2;\n\n                this.emit(isRightButton ? `rightup${eventAppend}` : `mouseup${eventAppend}`, interactionEvent);\n            }\n            else if (event.pointerType === 'touch')\n            {\n                this.emit(cancelled ? 'touchcancel' : `touchend${eventAppend}`, interactionEvent);\n                this.releaseInteractionDataForPointerId(event.pointerId);\n            }\n        }\n    }\n\n    /**\n     * Is called when the pointer button is cancelled\n     * @param event - The DOM event of a pointer button being released\n     */\n    private onPointerCancel(event: InteractivePointerEvent): void\n    {\n        // if we support touch events, then only use those for touch events, not pointer events\n        if (this.supportsTouchEvents && (event as PointerEvent).pointerType === 'touch') return;\n\n        this.onPointerComplete(event, true, this.processPointerCancel);\n    }\n\n    /**\n     * Processes the result of the pointer cancel check and dispatches the event if need be\n     * @param interactionEvent - The interaction event wrapping the DOM event\n     * @param displayObject - The display object that was tested\n     */\n    private processPointerCancel(interactionEvent: InteractionEvent, displayObject: DisplayObject): void\n    {\n        const data = interactionEvent.data;\n\n        const id = interactionEvent.data.identifier;\n\n        if (displayObject.trackedPointers[id] !== undefined)\n        {\n            delete displayObject.trackedPointers[id];\n            this.dispatchEvent(displayObject, 'pointercancel', interactionEvent);\n\n            if (data.pointerType === 'touch')\n            {\n                this.dispatchEvent(displayObject, 'touchcancel', interactionEvent);\n            }\n        }\n    }\n\n    /**\n     * Is called when the pointer button is released on the renderer element\n     * @param event - The DOM event of a pointer button being released\n     */\n    private onPointerUp(event: InteractivePointerEvent): void\n    {\n        // if we support touch events, then only use those for touch events, not pointer events\n        if (this.supportsTouchEvents && (event as PointerEvent).pointerType === 'touch') return;\n\n        this.onPointerComplete(event, false, this.processPointerUp);\n    }\n\n    /**\n     * Processes the result of the pointer up check and dispatches the event if need be\n     * @param interactionEvent - The interaction event wrapping the DOM event\n     * @param displayObject - The display object that was tested\n     * @param hit - the result of the hit test on the display object\n     */\n    private processPointerUp(interactionEvent: InteractionEvent, displayObject: DisplayObject, hit: boolean): void\n    {\n        const data = interactionEvent.data;\n\n        const id = interactionEvent.data.identifier;\n\n        const trackingData = displayObject.trackedPointers[id];\n\n        const isTouch = data.pointerType === 'touch';\n\n        const isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');\n        // need to track mouse down status in the mouse block so that we can emit\n        // event in a later block\n        let isMouseTap = false;\n\n        // Mouse only\n        if (isMouse)\n        {\n            const isRightButton = data.button === 2;\n\n            const flags = InteractionTrackingData.FLAGS;\n\n            const test = isRightButton ? flags.RIGHT_DOWN : flags.LEFT_DOWN;\n\n            const isDown = trackingData !== undefined && (trackingData.flags & test);\n\n            if (hit)\n            {\n                this.dispatchEvent(displayObject, isRightButton ? 'rightup' : 'mouseup', interactionEvent);\n\n                if (isDown)\n                {\n                    this.dispatchEvent(displayObject, isRightButton ? 'rightclick' : 'click', interactionEvent);\n                    // because we can confirm that the mousedown happened on this object, flag for later emit of pointertap\n                    isMouseTap = true;\n                }\n            }\n            else if (isDown)\n            {\n                this.dispatchEvent(displayObject, isRightButton ? 'rightupoutside' : 'mouseupoutside', interactionEvent);\n            }\n            // update the down state of the tracking data\n            if (trackingData)\n            {\n                if (isRightButton)\n                {\n                    trackingData.rightDown = false;\n                }\n                else\n                {\n                    trackingData.leftDown = false;\n                }\n            }\n        }\n\n        // Pointers and Touches, and Mouse\n        if (hit)\n        {\n            this.dispatchEvent(displayObject, 'pointerup', interactionEvent);\n            if (isTouch) this.dispatchEvent(displayObject, 'touchend', interactionEvent);\n\n            if (trackingData)\n            {\n                // emit pointertap if not a mouse, or if the mouse block decided it was a tap\n                if (!isMouse || isMouseTap)\n                {\n                    this.dispatchEvent(displayObject, 'pointertap', interactionEvent);\n                }\n                if (isTouch)\n                {\n                    this.dispatchEvent(displayObject, 'tap', interactionEvent);\n                    // touches are no longer over (if they ever were) when we get the touchend\n                    // so we should ensure that we don't keep pretending that they are\n                    trackingData.over = false;\n                }\n            }\n        }\n        else if (trackingData)\n        {\n            this.dispatchEvent(displayObject, 'pointerupoutside', interactionEvent);\n            if (isTouch) this.dispatchEvent(displayObject, 'touchendoutside', interactionEvent);\n        }\n        // Only remove the tracking data if there is no over/down state still associated with it\n        if (trackingData && trackingData.none)\n        {\n            delete displayObject.trackedPointers[id];\n        }\n    }\n\n    /**\n     * Is called when the pointer moves across the renderer element\n     * @param originalEvent - The DOM event of a pointer moving\n     */\n    private onPointerMove(originalEvent: InteractivePointerEvent): void\n    {\n        // if we support touch events, then only use those for touch events, not pointer events\n        if (this.supportsTouchEvents && (originalEvent as PointerEvent).pointerType === 'touch') return;\n\n        const events = this.normalizeToPointerData(originalEvent);\n\n        if (events[0].pointerType === 'mouse' || events[0].pointerType === 'pen')\n        {\n            this._didMove = true;\n\n            this.cursor = null;\n        }\n\n        const eventLen = events.length;\n\n        for (let i = 0; i < eventLen; i++)\n        {\n            const event = events[i];\n\n            const interactionData = this.getInteractionDataForPointerId(event);\n\n            const interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);\n\n            interactionEvent.data.originalEvent = originalEvent;\n\n            this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerMove, true);\n\n            this.emit('pointermove', interactionEvent);\n            if (event.pointerType === 'touch') this.emit('touchmove', interactionEvent);\n            if (event.pointerType === 'mouse' || event.pointerType === 'pen') this.emit('mousemove', interactionEvent);\n        }\n\n        if (events[0].pointerType === 'mouse')\n        {\n            this.setCursorMode(this.cursor);\n\n            // TODO BUG for parents interactive object (border order issue)\n        }\n    }\n\n    /**\n     * Processes the result of the pointer move check and dispatches the event if need be\n     * @param interactionEvent - The interaction event wrapping the DOM event\n     * @param displayObject - The display object that was tested\n     * @param hit - the result of the hit test on the display object\n     */\n    private processPointerMove(interactionEvent: InteractionEvent, displayObject: DisplayObject, hit: boolean): void\n    {\n        const data = interactionEvent.data;\n\n        const isTouch = data.pointerType === 'touch';\n\n        const isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');\n\n        if (isMouse)\n        {\n            this.processPointerOverOut(interactionEvent, displayObject, hit);\n        }\n\n        if (!this.moveWhenInside || hit)\n        {\n            this.dispatchEvent(displayObject, 'pointermove', interactionEvent);\n            if (isTouch) this.dispatchEvent(displayObject, 'touchmove', interactionEvent);\n            if (isMouse) this.dispatchEvent(displayObject, 'mousemove', interactionEvent);\n        }\n    }\n\n    /**\n     * Is called when the pointer is moved out of the renderer element\n     * @private\n     * @param {PointerEvent} originalEvent - The DOM event of a pointer being moved out\n     */\n    private onPointerOut(originalEvent: InteractivePointerEvent): void\n    {\n        // if we support touch events, then only use those for touch events, not pointer events\n        if (this.supportsTouchEvents && (originalEvent as PointerEvent).pointerType === 'touch') return;\n\n        const events = this.normalizeToPointerData(originalEvent);\n\n        // Only mouse and pointer can call onPointerOut, so events will always be length 1\n        const event = events[0];\n\n        if (event.pointerType === 'mouse')\n        {\n            this.mouseOverRenderer = false;\n            this.setCursorMode(null);\n        }\n\n        const interactionData = this.getInteractionDataForPointerId(event);\n\n        const interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);\n\n        interactionEvent.data.originalEvent = event;\n\n        this.processInteractive(interactionEvent, this.lastObjectRendered, this.processPointerOverOut, false);\n\n        this.emit('pointerout', interactionEvent);\n        if (event.pointerType === 'mouse' || event.pointerType === 'pen')\n        {\n            this.emit('mouseout', interactionEvent);\n        }\n        else\n        {\n            // we can get touchleave events after touchend, so we want to make sure we don't\n            // introduce memory leaks\n            this.releaseInteractionDataForPointerId(interactionData.identifier);\n        }\n    }\n\n    /**\n     * Processes the result of the pointer over/out check and dispatches the event if need be.\n     * @param interactionEvent - The interaction event wrapping the DOM event\n     * @param displayObject - The display object that was tested\n     * @param hit - the result of the hit test on the display object\n     */\n    private processPointerOverOut(interactionEvent: InteractionEvent, displayObject: DisplayObject, hit: boolean): void\n    {\n        const data = interactionEvent.data;\n\n        const id = interactionEvent.data.identifier;\n\n        const isMouse = (data.pointerType === 'mouse' || data.pointerType === 'pen');\n\n        let trackingData = displayObject.trackedPointers[id];\n\n        // if we just moused over the display object, then we need to track that state\n        if (hit && !trackingData)\n        {\n            trackingData = displayObject.trackedPointers[id] = new InteractionTrackingData(id);\n        }\n\n        if (trackingData === undefined) return;\n\n        if (hit && this.mouseOverRenderer)\n        {\n            if (!trackingData.over)\n            {\n                trackingData.over = true;\n                this.delayDispatchEvent(displayObject, 'pointerover', interactionEvent);\n                if (isMouse)\n                {\n                    this.delayDispatchEvent(displayObject, 'mouseover', interactionEvent);\n                }\n            }\n\n            // only change the cursor if it has not already been changed (by something deeper in the\n            // display tree)\n            if (isMouse && this.cursor === null)\n            {\n                this.cursor = displayObject.cursor;\n            }\n        }\n        else if (trackingData.over)\n        {\n            trackingData.over = false;\n            this.dispatchEvent(displayObject, 'pointerout', this.eventData);\n            if (isMouse)\n            {\n                this.dispatchEvent(displayObject, 'mouseout', interactionEvent);\n            }\n            // if there is no mouse down information for the pointer, then it is safe to delete\n            if (trackingData.none)\n            {\n                delete displayObject.trackedPointers[id];\n            }\n        }\n    }\n\n    /**\n     * Is called when the pointer is moved into the renderer element.\n     * @param originalEvent - The DOM event of a pointer button being moved into the renderer view.\n     */\n    private onPointerOver(originalEvent: InteractivePointerEvent): void\n    {\n        if (this.supportsTouchEvents && (originalEvent as PointerEvent).pointerType === 'touch') return;\n\n        const events = this.normalizeToPointerData(originalEvent);\n\n        // Only mouse and pointer can call onPointerOver, so events will always be length 1\n        const event = events[0];\n\n        const interactionData = this.getInteractionDataForPointerId(event);\n\n        const interactionEvent = this.configureInteractionEventForDOMEvent(this.eventData, event, interactionData);\n\n        interactionEvent.data.originalEvent = event;\n\n        if (event.pointerType === 'mouse')\n        {\n            this.mouseOverRenderer = true;\n        }\n\n        this.emit('pointerover', interactionEvent);\n        if (event.pointerType === 'mouse' || event.pointerType === 'pen')\n        {\n            this.emit('mouseover', interactionEvent);\n        }\n    }\n\n    /**\n     * Get InteractionData for a given pointerId. Store that data as well.\n     * @param event - Normalized pointer event, output from normalizeToPointerData.\n     * @returns - Interaction data for the given pointer identifier.\n     */\n    private getInteractionDataForPointerId(event: PointerEvent): InteractionData\n    {\n        const pointerId = event.pointerId;\n\n        let interactionData;\n\n        if (pointerId === MOUSE_POINTER_ID || event.pointerType === 'mouse')\n        {\n            interactionData = this.mouse;\n        }\n        else if (this.activeInteractionData[pointerId])\n        {\n            interactionData = this.activeInteractionData[pointerId];\n        }\n        else\n        {\n            interactionData = this.interactionDataPool.pop() || new InteractionData();\n            interactionData.identifier = pointerId;\n            this.activeInteractionData[pointerId] = interactionData;\n        }\n        // copy properties from the event, so that we can make sure that touch/pointer specific\n        // data is available\n        interactionData.copyEvent(event);\n\n        return interactionData;\n    }\n\n    /**\n     * Return unused InteractionData to the pool, for a given pointerId\n     * @param pointerId - Identifier from a pointer event\n     */\n    private releaseInteractionDataForPointerId(pointerId: number): void\n    {\n        const interactionData = this.activeInteractionData[pointerId];\n\n        if (interactionData)\n        {\n            delete this.activeInteractionData[pointerId];\n            interactionData.reset();\n            this.interactionDataPool.push(interactionData);\n        }\n    }\n\n    /**\n     * Configure an InteractionEvent to wrap a DOM PointerEvent and InteractionData\n     * @param interactionEvent - The event to be configured\n     * @param pointerEvent - The DOM event that will be paired with the InteractionEvent\n     * @param interactionData - The InteractionData that will be paired\n     *        with the InteractionEvent\n     * @returns - the interaction event that was passed in\n     */\n    private configureInteractionEventForDOMEvent(interactionEvent: InteractionEvent, pointerEvent: PointerEvent,\n        interactionData: InteractionData\n    ): InteractionEvent\n    {\n        interactionEvent.data = interactionData;\n\n        this.mapPositionToPoint(interactionData.global, pointerEvent.clientX, pointerEvent.clientY);\n\n        // Not really sure why this is happening, but it's how a previous version handled things\n        if (pointerEvent.pointerType === 'touch')\n        {\n            (pointerEvent as any).globalX = interactionData.global.x;\n            (pointerEvent as any).globalY = interactionData.global.y;\n        }\n\n        interactionData.originalEvent = pointerEvent;\n        interactionEvent.reset();\n\n        return interactionEvent;\n    }\n\n    /**\n     * Ensures that the original event object contains all data that a regular pointer event would have\n     * @param {TouchEvent|MouseEvent|PointerEvent} event - The original event data from a touch or mouse event\n     * @returns - An array containing a single normalized pointer event, in the case of a pointer\n     *  or mouse event, or a multiple normalized pointer events if there are multiple changed touches\n     */\n    private normalizeToPointerData(event: InteractivePointerEvent): PointerEvent[]\n    {\n        const normalizedEvents = [];\n\n        if (this.supportsTouchEvents && event instanceof TouchEvent)\n        {\n            for (let i = 0, li = event.changedTouches.length; i < li; i++)\n            {\n                const touch = event.changedTouches[i] as PixiTouch;\n\n                if (typeof touch.button === 'undefined') touch.button = event.touches.length ? 1 : 0;\n                if (typeof touch.buttons === 'undefined') touch.buttons = event.touches.length ? 1 : 0;\n                if (typeof touch.isPrimary === 'undefined')\n                {\n                    touch.isPrimary = event.touches.length === 1 && event.type === 'touchstart';\n                }\n                if (typeof touch.width === 'undefined') touch.width = touch.radiusX || 1;\n                if (typeof touch.height === 'undefined') touch.height = touch.radiusY || 1;\n                if (typeof touch.tiltX === 'undefined') touch.tiltX = 0;\n                if (typeof touch.tiltY === 'undefined') touch.tiltY = 0;\n                if (typeof touch.pointerType === 'undefined') touch.pointerType = 'touch';\n                if (typeof touch.pointerId === 'undefined') touch.pointerId = touch.identifier || 0;\n                if (typeof touch.pressure === 'undefined') touch.pressure = touch.force || 0.5;\n                if (typeof touch.twist === 'undefined') touch.twist = 0;\n                if (typeof touch.tangentialPressure === 'undefined') touch.tangentialPressure = 0;\n                // TODO: Remove these, as layerX/Y is not a standard, is deprecated, has uneven\n                // support, and the fill ins are not quite the same\n                // offsetX/Y might be okay, but is not the same as clientX/Y when the canvas's top\n                // left is not 0,0 on the page\n                if (typeof touch.layerX === 'undefined') touch.layerX = touch.offsetX = touch.clientX;\n                if (typeof touch.layerY === 'undefined') touch.layerY = touch.offsetY = touch.clientY;\n\n                // mark the touch as normalized, just so that we know we did it\n                touch.isNormalized = true;\n\n                normalizedEvents.push(touch);\n            }\n        }\n        // apparently PointerEvent subclasses MouseEvent, so yay\n        else if (!globalThis.MouseEvent\n            || (event instanceof MouseEvent && (!this.supportsPointerEvents || !(event instanceof globalThis.PointerEvent))))\n        {\n            const tempEvent = event as PixiPointerEvent;\n\n            if (typeof tempEvent.isPrimary === 'undefined') tempEvent.isPrimary = true;\n            if (typeof tempEvent.width === 'undefined') tempEvent.width = 1;\n            if (typeof tempEvent.height === 'undefined') tempEvent.height = 1;\n            if (typeof tempEvent.tiltX === 'undefined') tempEvent.tiltX = 0;\n            if (typeof tempEvent.tiltY === 'undefined') tempEvent.tiltY = 0;\n            if (typeof tempEvent.pointerType === 'undefined') tempEvent.pointerType = 'mouse';\n            if (typeof tempEvent.pointerId === 'undefined') tempEvent.pointerId = MOUSE_POINTER_ID;\n            if (typeof tempEvent.pressure === 'undefined') tempEvent.pressure = 0.5;\n            if (typeof tempEvent.twist === 'undefined') tempEvent.twist = 0;\n            if (typeof tempEvent.tangentialPressure === 'undefined') tempEvent.tangentialPressure = 0;\n\n            // mark the mouse event as normalized, just so that we know we did it\n            tempEvent.isNormalized = true;\n\n            normalizedEvents.push(tempEvent);\n        }\n        else\n        {\n            normalizedEvents.push(event);\n        }\n\n        return normalizedEvents as PointerEvent[];\n    }\n\n    /** Destroys the interaction manager. */\n    public destroy(): void\n    {\n        this.removeEvents();\n\n        this.removeTickerListener();\n\n        this.removeAllListeners();\n\n        this.renderer = null;\n\n        this.mouse = null;\n\n        this.eventData = null;\n\n        this.interactionDOMElement = null;\n\n        this.onPointerDown = null;\n        this.processPointerDown = null;\n\n        this.onPointerUp = null;\n        this.processPointerUp = null;\n\n        this.onPointerCancel = null;\n        this.processPointerCancel = null;\n\n        this.onPointerMove = null;\n        this.processPointerMove = null;\n\n        this.onPointerOut = null;\n        this.processPointerOverOut = null;\n\n        this.onPointerOver = null;\n\n        this.search = null;\n    }\n}\n\ninterface PixiPointerEvent extends PointerEvent\n{\n    isPrimary: boolean;\n    width: number;\n    height: number;\n    tiltX: number;\n    tiltY: number;\n    pointerType: string;\n    pointerId: number;\n    pressure: number;\n    twist: number;\n    tangentialPressure: number;\n    isNormalized: boolean;\n}\n\ninterface PixiTouch extends Touch\n{\n    button: number;\n    buttons: number;\n    isPrimary: boolean;\n    width: number;\n    height: number;\n    tiltX: number;\n    tiltY: number;\n    pointerType: string;\n    pointerId: number;\n    pressure: number;\n    twist: number;\n    tangentialPressure: number;\n    layerX: number;\n    layerY: number;\n    offsetX: number;\n    offsetY: number;\n    isNormalized: boolean;\n}\n","/**\n * WebGL internal formats, including compressed texture formats provided by extensions\n * @memberof PIXI\n * @static\n * @name INTERNAL_FORMATS\n * @enum {number}\n * @property {number} [COMPRESSED_RGB_S3TC_DXT1_EXT=0x83F0] -\n * @property {number} [COMPRESSED_RGBA_S3TC_DXT1_EXT=0x83F1] -\n * @property {number} [COMPRESSED_RGBA_S3TC_DXT3_EXT=0x83F2] -\n * @property {number} [COMPRESSED_RGBA_S3TC_DXT5_EXT=0x83F3] -\n * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=35917] -\n * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=35918] -\n * @property {number} [COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=35919] -\n * @property {number} [COMPRESSED_SRGB_S3TC_DXT1_EXT=35916] -\n * @property {number} [COMPRESSED_R11_EAC=0x9270] -\n * @property {number} [COMPRESSED_SIGNED_R11_EAC=0x9271] -\n * @property {number} [COMPRESSED_RG11_EAC=0x9272] -\n * @property {number} [COMPRESSED_SIGNED_RG11_EAC=0x9273] -\n * @property {number} [COMPRESSED_RGB8_ETC2=0x9274] -\n * @property {number} [COMPRESSED_RGBA8_ETC2_EAC=0x9278] -\n * @property {number} [COMPRESSED_SRGB8_ETC2=0x9275] -\n * @property {number} [COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=0x9279] -\n * @property {number} [COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9276] -\n * @property {number} [COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=0x9277] -\n * @property {number} [COMPRESSED_RGB_PVRTC_4BPPV1_IMG=0x8C00] -\n * @property {number} [COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=0x8C02] -\n * @property {number} [COMPRESSED_RGB_PVRTC_2BPPV1_IMG=0x8C01] -\n * @property {number} [COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=0x8C03] -\n * @property {number} [COMPRESSED_RGB_ETC1_WEBGL=0x8D64] -\n * @property {number} [COMPRESSED_RGB_ATC_WEBGL=0x8C92] -\n * @property {number} [COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL=0x8C92] -\n * @property {number} [COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL=0x87EE] -\n * @property {number} [COMPRESSED_RGBA_ASTC_4x4_KHR=0x93B0] -\n */\nexport enum INTERNAL_FORMATS\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    // WEBGL_compressed_texture_s3tc\n    COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0,\n    COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1,\n    COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2,\n    COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3,\n\n    // WEBGL_compressed_texture_s3tc_srgb\n    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 35917,\n    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 35918,\n    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 35919,\n    COMPRESSED_SRGB_S3TC_DXT1_EXT = 35916,\n\n    // WEBGL_compressed_texture_etc\n    COMPRESSED_R11_EAC = 0x9270,\n    COMPRESSED_SIGNED_R11_EAC = 0x9271,\n    COMPRESSED_RG11_EAC = 0x9272,\n    COMPRESSED_SIGNED_RG11_EAC = 0x9273,\n    COMPRESSED_RGB8_ETC2 = 0x9274,\n    COMPRESSED_RGBA8_ETC2_EAC = 0x9278,\n    COMPRESSED_SRGB8_ETC2 = 0x9275,\n    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279,\n    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276,\n    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277,\n\n    // WEBGL_compressed_texture_pvrtc\n    COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00,\n    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02,\n    COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01,\n    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03,\n\n    // WEBGL_compressed_texture_etc1\n    COMPRESSED_RGB_ETC1_WEBGL = 0x8D64,\n\n    // WEBGL_compressed_texture_atc\n    COMPRESSED_RGB_ATC_WEBGL = 0x8C92,\n    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL = 0x8C92, // TODO: Probably a bug on the MDN site\n    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 0x87EE,\n\n    // WEBGL_compressed_texture_astc\n    /* eslint-disable-next-line camelcase */\n    COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0,\n}\n\n/**\n * Maps the compressed texture formats in {@link PIXI.INTERNAL_FORMATS} to the number of bytes taken by\n * each texel.\n * @memberof PIXI\n * @static\n * @ignore\n */\nexport const INTERNAL_FORMAT_TO_BYTES_PER_PIXEL: { [id: number]: number } = {\n    // WEBGL_compressed_texture_s3tc\n    [INTERNAL_FORMATS.COMPRESSED_RGB_S3TC_DXT1_EXT]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT]: 1,\n\n    // WEBGL_compressed_texture_s3tc\n    [INTERNAL_FORMATS.COMPRESSED_SRGB_S3TC_DXT1_EXT]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT]: 1,\n\n    // WEBGL_compressed_texture_etc\n    [INTERNAL_FORMATS.COMPRESSED_R11_EAC]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_SIGNED_R11_EAC]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RG11_EAC]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_SIGNED_RG11_EAC]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_RGB8_ETC2]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA8_ETC2_EAC]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_SRGB8_ETC2]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2]: 0.5, // ~~\n    [INTERNAL_FORMATS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2]: 0.5, // ~~\n\n    // WEBGL_compressed_texture_pvrtc\n    [INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: 0.25,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG]: 0.25,\n\n    // WEBGL_compressed_texture_etc1\n    [INTERNAL_FORMATS.COMPRESSED_RGB_ETC1_WEBGL]: 0.5,\n\n    // @see https://www.khronos.org/registry/OpenGL/extensions/AMD/AMD_compressed_ATC_texture.txt\n    // WEBGL_compressed_texture_atc\n    [INTERNAL_FORMATS.COMPRESSED_RGB_ATC_WEBGL]: 0.5,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL]: 1,\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL]: 1,\n\n    // @see https://registry.khronos.org/OpenGL/extensions/KHR/KHR_texture_compression_astc_hdr.txt\n    // WEBGL_compressed_texture_astc\n    /* eslint-disable-next-line camelcase */\n    [INTERNAL_FORMATS.COMPRESSED_RGBA_ASTC_4x4_KHR]: 1,\n};\n","import { MSAA_QUALITY } from '@pixi/constants';\nimport { CanvasRenderTarget } from '@pixi/utils';\nimport { Rectangle } from '@pixi/math';\nimport { ExtensionType, RenderTexture } from '@pixi/core';\n\nimport type { Renderer, IRendererPlugin, ExtensionMetadata } from '@pixi/core';\nimport type { DisplayObject } from '@pixi/display';\n\nconst TEMP_RECT = new Rectangle();\nconst BYTES_PER_PIXEL = 4;\n\n/**\n * this interface is used to extract only  a single pixel of Render Texture or Display Object\n * if you use this Interface all fields is required\n * @deprecated\n * @example\n * test: PixelExtractOptions = { x: 15, y: 20, resolution: 4, width: 10, height: 10 }\n */\nexport interface PixelExtractOptions\n{\n    x: number,\n    y: number,\n    height: number,\n    resolution: number,\n    width: number\n}\n\n/**\n * This class provides renderer-specific plugins for exporting content from a renderer.\n * For instance, these plugins can be used for saving an Image, Canvas element or for exporting the raw image data (pixels).\n *\n * Do not instantiate these plugins directly. It is available from the `renderer.plugins` property.\n * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.\n * @example\n * // Create a new app (will auto-add extract plugin to renderer)\n * const app = new PIXI.Application();\n *\n * // Draw a red circle\n * const graphics = new PIXI.Graphics()\n *     .beginFill(0xFF0000)\n *     .drawCircle(0, 0, 50);\n *\n * // Render the graphics as an HTMLImageElement\n * const image = app.renderer.plugins.extract.image(graphics);\n * document.body.appendChild(image);\n * @memberof PIXI\n */\n\nexport class Extract implements IRendererPlugin\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'extract',\n        type: ExtensionType.RendererPlugin,\n    };\n\n    private renderer: Renderer;\n\n    /**\n     * @param renderer - A reference to the current renderer\n     */\n    constructor(renderer: Renderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * Will return a HTML Image of the target\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param format - Image format, e.g. \"image/jpeg\" or \"image/webp\".\n     * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.\n     * @returns - HTML Image of the target\n     */\n    public image(target: DisplayObject | RenderTexture, format?: string, quality?: number): HTMLImageElement\n    {\n        const image = new Image();\n\n        image.src = this.base64(target, format, quality);\n\n        return image;\n    }\n\n    /**\n     * Will return a base64 encoded string of this target. It works by calling\n     *  `Extract.getCanvas` and then running toDataURL on that.\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param format - Image format, e.g. \"image/jpeg\" or \"image/webp\".\n     * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.\n     * @returns - A base64 encoded string of the texture.\n     */\n    public base64(target: DisplayObject | RenderTexture, format?: string, quality?: number): string\n    {\n        return this.canvas(target).toDataURL(format, quality);\n    }\n\n    /**\n     * Creates a Canvas element, renders this target to it and then returns it.\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param frame - The frame the extraction is restricted to.\n     * @returns - A Canvas element with the texture rendered on.\n     */\n    public canvas(target?: DisplayObject | RenderTexture, frame?: Rectangle): HTMLCanvasElement\n    {\n        const { pixels, width, height, flipY } = this._rawPixels(target, frame);\n\n        let canvasBuffer = new CanvasRenderTarget(width, height, 1);\n\n        // Add the pixels to the canvas\n        const canvasData = canvasBuffer.context.getImageData(0, 0, width, height);\n\n        Extract.arrayPostDivide(pixels, canvasData.data);\n\n        canvasBuffer.context.putImageData(canvasData, 0, 0);\n\n        // Flipping pixels\n        if (flipY)\n        {\n            const target = new CanvasRenderTarget(canvasBuffer.width, canvasBuffer.height, 1);\n\n            target.context.scale(1, -1);\n\n            // We can't render to itself because we should be empty before render.\n            target.context.drawImage(canvasBuffer.canvas, 0, -height);\n\n            canvasBuffer.destroy();\n            canvasBuffer = target;\n        }\n\n        // Send the canvas back\n        return canvasBuffer.canvas;\n    }\n\n    /**\n     * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA\n     * order, with integer values between 0 and 255 (included).\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param frame - The frame the extraction is restricted to.\n     * @returns - One-dimensional array containing the pixel data of the entire texture\n     */\n    public pixels(target?: DisplayObject | RenderTexture, frame?: Rectangle | PixelExtractOptions): Uint8Array\n    {\n        const { pixels } = this._rawPixels(target, frame as Rectangle);\n\n        Extract.arrayPostDivide(pixels, pixels);\n\n        return pixels;\n    }\n\n    private _rawPixels(target?: DisplayObject | RenderTexture, frame?: Rectangle): {\n        pixels: Uint8Array, width: number, height: number, flipY: boolean,\n    }\n    {\n        const renderer = this.renderer;\n        let resolution;\n        let flipY = false;\n        let renderTexture;\n        let generated = false;\n\n        if (target)\n        {\n            if (target instanceof RenderTexture)\n            {\n                renderTexture = target;\n            }\n            else\n            {\n                const multisample = renderer.context.webGLVersion >= 2 ? renderer.multisample : MSAA_QUALITY.NONE;\n\n                renderTexture = this.renderer.generateTexture(target, { multisample });\n\n                if (multisample !== MSAA_QUALITY.NONE)\n                {\n                    // Resolve the multisampled texture to a non-multisampled texture\n                    const resolvedTexture = RenderTexture.create({\n                        width: renderTexture.width,\n                        height: renderTexture.height,\n                    });\n\n                    renderer.framebuffer.bind(renderTexture.framebuffer);\n                    renderer.framebuffer.blit(resolvedTexture.framebuffer);\n                    renderer.framebuffer.bind(null);\n\n                    renderTexture.destroy(true);\n                    renderTexture = resolvedTexture;\n                }\n\n                generated = true;\n            }\n        }\n\n        if (renderTexture)\n        {\n            resolution = renderTexture.baseTexture.resolution;\n            frame = frame ?? renderTexture.frame;\n            flipY = false;\n            renderer.renderTexture.bind(renderTexture);\n        }\n        else\n        {\n            resolution = renderer.resolution;\n\n            if (!frame)\n            {\n                frame = TEMP_RECT;\n                frame.width = renderer.width;\n                frame.height = renderer.height;\n            }\n\n            flipY = true;\n            renderer.renderTexture.bind(null);\n        }\n\n        const width = Math.round(frame.width * resolution);\n        const height = Math.round(frame.height * resolution);\n\n        const pixels = new Uint8Array(BYTES_PER_PIXEL * width * height);\n\n        // Read pixels to the array\n        const gl = renderer.gl;\n\n        gl.readPixels(\n            Math.round(frame.x * resolution),\n            Math.round(frame.y * resolution),\n            width,\n            height,\n            gl.RGBA,\n            gl.UNSIGNED_BYTE,\n            pixels\n        );\n\n        if (generated)\n        {\n            renderTexture.destroy(true);\n        }\n\n        return { pixels, width, height, flipY };\n    }\n\n    /** Destroys the extract. */\n    public destroy(): void\n    {\n        this.renderer = null;\n    }\n\n    /**\n     * Takes premultiplied pixel data and produces regular pixel data\n     * @private\n     * @param pixels - array of pixel data\n     * @param out - output array\n     */\n    static arrayPostDivide(\n        pixels: number[] | Uint8Array | Uint8ClampedArray, out: number[] | Uint8Array | Uint8ClampedArray\n    ): void\n    {\n        for (let i = 0; i < pixels.length; i += 4)\n        {\n            const alpha = out[i + 3] = pixels[i + 3];\n\n            if (alpha !== 0)\n            {\n                out[i] = Math.round(Math.min(pixels[i] * 255.0 / alpha, 255.0));\n                out[i + 1] = Math.round(Math.min(pixels[i + 1] * 255.0 / alpha, 255.0));\n                out[i + 2] = Math.round(Math.min(pixels[i + 2] * 255.0 / alpha, 255.0));\n            }\n            else\n            {\n                out[i] = pixels[i];\n                out[i + 1] = pixels[i + 1];\n                out[i + 2] = pixels[i + 2];\n            }\n        }\n    }\n}\n","import type { Resource } from '@pixi/core';\nimport { ViewableBuffer, BufferResource } from '@pixi/core';\n\ninterface IBlobOptions\n{\n    autoLoad?: boolean;\n    width: number;\n    height: number;\n}\n\n/**\n * Resource that fetches texture data over the network and stores it in a buffer.\n * @class\n * @extends PIXI.Resource\n * @memberof PIXI\n */\nexport abstract class BlobResource extends BufferResource\n{\n    protected origin: string;\n    protected buffer: ViewableBuffer;\n    protected loaded: boolean;\n\n    /**\n     * @param {string} source - the URL of the texture file\n     * @param {PIXI.IBlobOptions} options\n     * @param {boolean}[options.autoLoad] - whether to fetch the data immediately;\n     *  you can fetch it later via {@link BlobResource#load}\n     * @param {boolean}[options.width] - the width in pixels.\n     * @param {boolean}[options.height] - the height in pixels.\n     */\n    constructor(source: string | Uint8Array | Uint32Array | Float32Array,\n        options: IBlobOptions = { width: 1, height: 1, autoLoad: true })\n    {\n        let origin: string;\n        let data: Uint8Array | Uint32Array | Float32Array;\n\n        if (typeof source === 'string')\n        {\n            origin = source;\n            data = new Uint8Array();\n        }\n        else\n        {\n            origin = null;\n            data = source;\n        }\n\n        super(data, options);\n\n        /**\n         * The URL of the texture file\n         * @member {string}\n         */\n        this.origin = origin;\n\n        /**\n         * The viewable buffer on the data\n         * @member {ViewableBuffer}\n         */\n        // HINT: BlobResource allows \"null\" sources, assuming the child class provides an alternative\n        this.buffer = data ? new ViewableBuffer(data) : null;\n\n        // Allow autoLoad = \"undefined\" still load the resource by default\n        if (this.origin && options.autoLoad !== false)\n        {\n            this.load();\n        }\n        if (data && data.length)\n        {\n            this.loaded = true;\n            this.onBlobLoaded(this.buffer.rawBinaryData);\n        }\n    }\n\n    protected onBlobLoaded(_data: ArrayBuffer): void\n    {\n        // TODO: Override this method\n    }\n\n    /** Loads the blob */\n    async load(): Promise<Resource>\n    {\n        const response = await fetch(this.origin);\n        const blob = await response.blob();\n        const arrayBuffer = await blob.arrayBuffer();\n\n        this.data = new Uint32Array(arrayBuffer);\n        this.buffer = new ViewableBuffer(arrayBuffer);\n        this.loaded = true;\n\n        this.onBlobLoaded(arrayBuffer);\n        this.update();\n\n        return this;\n    }\n}\n","import { BlobResource } from './BlobResource';\nimport { INTERNAL_FORMAT_TO_BYTES_PER_PIXEL } from '../const';\nimport type { Renderer, BaseTexture, GLTexture } from '@pixi/core';\n\nimport type { INTERNAL_FORMATS } from '../const';\n\n/**\n * @ignore\n */\n// Used in PIXI.KTXLoader\nexport type CompressedLevelBuffer = {\n    levelID: number,\n    levelWidth: number,\n    levelHeight: number,\n    levelBuffer: Uint8Array\n};\n\n/**\n * @ignore\n */\nexport interface ICompressedTextureResourceOptions\n{\n    format: INTERNAL_FORMATS;\n    width: number;\n    height: number;\n    levels?: number;\n    levelBuffers?: CompressedLevelBuffer[];\n}\n\n/**\n * Resource for compressed texture formats, as follows: S3TC/DXTn (& their sRGB formats), ATC, ASTC, ETC 1/2, PVRTC.\n *\n * Compressed textures improve performance when rendering is texture-bound. The texture data stays compressed in\n * graphics memory, increasing memory locality and speeding up texture fetches. These formats can also be used to store\n * more detail in the same amount of memory.\n *\n * For most developers, container file formats are a better abstraction instead of directly handling raw texture\n * data. PixiJS provides native support for the following texture file formats (via {@link PIXI.Loader}):\n *\n * **.dds** - the DirectDraw Surface file format stores DXTn (DXT-1,3,5) data. See {@link PIXI.DDSLoader}\n * **.ktx** - the Khronos Texture Container file format supports storing all the supported WebGL compression formats.\n *  See {@link PIXI.KTXLoader}.\n * **.basis** - the BASIS supercompressed file format stores texture data in an internal format that is transcoded\n *  to the compression format supported on the device at _runtime_. It also supports transcoding into a uncompressed\n *  format as a fallback; you must install the `@pixi/basis-loader`, `@pixi/basis-transcoder` packages separately to\n *  use these files. See {@link PIXI.BasisLoader}.\n *\n * The loaders for the aforementioned formats use `CompressedTextureResource` internally. It is strongly suggested that\n * they be used instead.\n *\n * ## Working directly with CompressedTextureResource\n *\n * Since `CompressedTextureResource` inherits `BlobResource`, you can provide it a URL pointing to a file containing\n * the raw texture data (with no file headers!):\n *\n * ```js\n * // The resource backing the texture data for your textures.\n * // NOTE: You can also provide a ArrayBufferView instead of a URL. This is used when loading data from a container file\n * //   format such as KTX, DDS, or BASIS.\n * const compressedResource = new PIXI.CompressedTextureResource(\"bunny.dxt5\", {\n *   format: PIXI.INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,\n *   width: 256,\n *   height: 256\n * });\n *\n * // You can create a base-texture to the cache, so that future `Texture`s can be created using the `Texture.from` API.\n * const baseTexture = new PIXI.BaseTexture(compressedResource, { pmaMode: PIXI.ALPHA_MODES.NPM });\n *\n * // Create a Texture to add to the TextureCache\n * const texture = new PIXI.Texture(baseTexture);\n *\n * // Add baseTexture & texture to the global texture cache\n * PIXI.BaseTexture.addToCache(baseTexture, \"bunny.dxt5\");\n * PIXI.Texture.addToCache(texture, \"bunny.dxt5\");\n * ```\n * @memberof PIXI\n */\nexport class CompressedTextureResource extends BlobResource\n{\n    /** The compression format */\n    public format: INTERNAL_FORMATS;\n    /**\n     * The number of mipmap levels stored in the resource buffer.\n     * @default 1\n     */\n    public levels: number;\n\n    // Easy access to the WebGL extension providing support for the compression format via ContextSystem\n    private _extension: 's3tc' | 's3tc_sRGB' | 'atc' | 'astc' | 'etc' | 'etc1' | 'pvrtc';\n    // Buffer views for each mipmap level in the main buffer\n    private _levelBuffers: CompressedLevelBuffer[];\n\n    /**\n     * @param source - the buffer/URL holding the compressed texture data\n     * @param options\n     * @param {PIXI.INTERNAL_FORMATS} options.format - the compression format\n     * @param {number} options.width - the image width in pixels.\n     * @param {number} options.height - the image height in pixels.\n     * @param {number} [options.level=1] - the mipmap levels stored in the compressed texture, including level 0.\n     * @param {number} [options.levelBuffers] - the buffers for each mipmap level. `CompressedTextureResource` can allows you\n     *      to pass `null` for `source`, for cases where each level is stored in non-contiguous memory.\n     */\n    constructor(source: string | Uint8Array | Uint32Array, options: ICompressedTextureResourceOptions)\n    {\n        super(source, options);\n\n        this.format = options.format;\n        this.levels = options.levels || 1;\n\n        this._width = options.width;\n        this._height = options.height;\n\n        this._extension = CompressedTextureResource._formatToExtension(this.format);\n\n        if (options.levelBuffers || this.buffer)\n        {\n            // ViewableBuffer doesn't support byteOffset :-( so allow source to be Uint8Array\n            this._levelBuffers = options.levelBuffers\n                || CompressedTextureResource._createLevelBuffers(\n                    source instanceof Uint8Array ? source : this.buffer.uint8View,\n                    this.format,\n                    this.levels,\n                    4, 4, // PVRTC has 8x4 blocks in 2bpp mode\n                    this.width,\n                    this.height);\n        }\n    }\n\n    /**\n     * @override\n     * @param renderer - A reference to the current renderer\n     * @param _texture - the texture\n     * @param _glTexture - texture instance for this webgl context\n     */\n    upload(renderer: Renderer, _texture: BaseTexture, _glTexture: GLTexture): boolean\n    {\n        const gl = renderer.gl;\n        const extension = renderer.context.extensions[this._extension];\n\n        if (!extension)\n        {\n            throw new Error(`${this._extension} textures are not supported on the current machine`);\n        }\n        if (!this._levelBuffers)\n        {\n            // Do not try to upload data before BlobResource loads, unless the levelBuffers were provided directly!\n            return false;\n        }\n\n        for (let i = 0, j = this.levels; i < j; i++)\n        {\n            const { levelID, levelWidth, levelHeight, levelBuffer } = this._levelBuffers[i];\n\n            gl.compressedTexImage2D(gl.TEXTURE_2D, levelID, this.format, levelWidth, levelHeight, 0, levelBuffer);\n        }\n\n        return true;\n    }\n\n    /** @protected */\n    protected onBlobLoaded(): void\n    {\n        this._levelBuffers = CompressedTextureResource._createLevelBuffers(\n            this.buffer.uint8View,\n            this.format,\n            this.levels,\n            4, 4, // PVRTC has 8x4 blocks in 2bpp mode\n            this.width,\n            this.height);\n    }\n\n    /**\n     * Returns the key (to ContextSystem#extensions) for the WebGL extension supporting the compression format\n     * @private\n     * @param format - the compression format to get the extension for.\n     */\n    private static _formatToExtension(format: INTERNAL_FORMATS):\n    's3tc' | 's3tc_sRGB' | 'atc' |\n    'astc' | 'etc' | 'etc1' | 'pvrtc'\n    {\n        if (format >= 0x83F0 && format <= 0x83F3)\n        {\n            return 's3tc';\n        }\n        else if (format >= 0x9270 && format <= 0x9279)\n        {\n            return 'etc';\n        }\n        else if (format >= 0x8C00 && format <= 0x8C03)\n        {\n            return 'pvrtc';\n        }\n        else if (format >= 0x8D64)\n        {\n            return 'etc1';\n        }\n        else if (format >= 0x8C92 && format <= 0x87EE)\n        {\n            return 'atc';\n        }\n\n        throw new Error('Invalid (compressed) texture format given!');\n    }\n\n    /**\n     * Pre-creates buffer views for each mipmap level\n     * @private\n     * @param buffer -\n     * @param format - compression formats\n     * @param levels - mipmap levels\n     * @param blockWidth -\n     * @param blockHeight -\n     * @param imageWidth - width of the image in pixels\n     * @param imageHeight - height of the image in pixels\n     */\n    private static _createLevelBuffers(\n        buffer: Uint8Array,\n        format: INTERNAL_FORMATS,\n        levels: number,\n        blockWidth: number,\n        blockHeight: number,\n        imageWidth: number,\n        imageHeight: number\n    ): CompressedLevelBuffer[]\n    {\n        // The byte-size of the first level buffer\n        const buffers = new Array<CompressedLevelBuffer>(levels);\n\n        let offset = buffer.byteOffset;\n\n        let levelWidth = imageWidth;\n        let levelHeight = imageHeight;\n        let alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);\n        let alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);\n\n        let levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];\n\n        for (let i = 0; i < levels; i++)\n        {\n            buffers[i] = {\n                levelID: i,\n                levelWidth: levels > 1 ? levelWidth : alignedLevelWidth,\n                levelHeight: levels > 1 ? levelHeight : alignedLevelHeight,\n                levelBuffer: new Uint8Array(buffer.buffer, offset, levelSize)\n            };\n\n            offset += levelSize;\n\n            // Calculate levelBuffer dimensions for next iteration\n            levelWidth = (levelWidth >> 1) || 1;\n            levelHeight = (levelHeight >> 1) || 1;\n            alignedLevelWidth = (levelWidth + blockWidth - 1) & ~(blockWidth - 1);\n            alignedLevelHeight = (levelHeight + blockHeight - 1) & ~(blockHeight - 1);\n            levelSize = alignedLevelWidth * alignedLevelHeight * INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[format];\n        }\n\n        return buffers;\n    }\n}\n","import { LoaderResource } from '@pixi/loaders';\nimport { url } from '@pixi/utils';\nimport { settings } from '@pixi/settings';\n\nimport type { Loader } from '@pixi/loaders';\nimport type { INTERNAL_FORMATS } from '../const';\nimport type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\n\n/**\n * Schema for compressed-texture manifests\n * @ignore\n * @see PIXI.CompressedTextureLoader\n */\nexport type CompressedTextureManifest = {\n    textures: Array<{ src: string, format?: keyof INTERNAL_FORMATS}>,\n    cacheID: string;\n};\n\n// Missing typings? - https://github.com/microsoft/TypeScript/issues/39655\n/** Compressed texture extensions */\n/* eslint-disable camelcase */\nexport type CompressedTextureExtensions = {\n    s3tc?: WEBGL_compressed_texture_s3tc,\n    s3tc_sRGB: WEBGL_compressed_texture_s3tc_srgb,\n    etc: any,\n    etc1: any,\n    pvrtc: any,\n    atc: any,\n    astc: WEBGL_compressed_texture_astc\n};\nexport type CompressedTextureExtensionRef = keyof CompressedTextureExtensions;\n/* eslint-enable camelcase */\n\n/**\n * Loader plugin for handling compressed textures for all platforms.\n * @class\n * @memberof PIXI\n * @implements {PIXI.ILoaderPlugin}\n */\nexport class CompressedTextureLoader\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Loader;\n\n    /**  Map of available texture extensions. */\n    private static _textureExtensions: Partial<CompressedTextureExtensions>;\n\n    /** Map of available texture formats. */\n    private static _textureFormats: { [P in keyof INTERNAL_FORMATS]?: number };\n\n    /**\n     * Called after a compressed-textures manifest is loaded.\n     *\n     * This will then load the correct compression format for the device. Your manifest should adhere\n     * to the following schema:\n     *\n     * ```js\n     * import { INTERNAL_FORMATS } from '@pixi/constants';\n     *\n     * type CompressedTextureManifest = {\n     *  textures: Array<{ src: string, format?: keyof INTERNAL_FORMATS}>,\n     *  cacheID: string;\n     * };\n     * ```\n     *\n     * This is an example of a .json manifest file\n     *\n     * ```json\n     * {\n     *   \"cacheID\":\"asset\",\n     *   \"textures\":[\n     *     { \"src\":\"asset.fallback.png\" },\n     *     { \"format\":\"COMPRESSED_RGBA_S3TC_DXT5_EXT\", \"src\":\"asset.s3tc.ktx\" },\n     *     { \"format\":\"COMPRESSED_RGBA8_ETC2_EAC\", \"src\":\"asset.etc.ktx\" },\n     *     { \"format\":\"RGBA_PVRTC_4BPPV1_IMG\", \"src\":\"asset.pvrtc.ktx\" }\n     *   ]\n     * }\n     * ```\n     */\n    static use(resource: LoaderResource, next: (...args: any[]) => void): void\n    {\n        const data: CompressedTextureManifest = resource.data;\n        const loader = this as unknown as Loader;\n\n        if (resource.type === LoaderResource.TYPE.JSON\n            && data\n            && data.cacheID\n            && data.textures)\n        {\n            const textures = data.textures;\n\n            let textureURL: string;\n            let fallbackURL: string;\n\n            // Search for an extension that holds one the formats\n            for (let i = 0, j = textures.length; i < j; i++)\n            {\n                const texture = textures[i];\n                const url = texture.src;\n                const format = texture.format;\n\n                if (!format)\n                {\n                    fallbackURL = url;\n                }\n                if (CompressedTextureLoader.textureFormats[format])\n                {\n                    textureURL = url;\n                    break;\n                }\n            }\n\n            textureURL = textureURL || fallbackURL;\n\n            // Make sure we have a URL\n            if (!textureURL)\n            {\n                next(new Error(`Cannot load compressed-textures in ${resource.url}, make sure you provide a fallback`));\n\n                return;\n            }\n            if (textureURL === resource.url)\n            {\n                // Prevent infinite loops\n                next(new Error('URL of compressed texture cannot be the same as the manifest\\'s URL'));\n\n                return;\n            }\n\n            const loadOptions = {\n                crossOrigin: resource.crossOrigin,\n                metadata: resource.metadata.imageMetadata,\n                parentResource: resource\n            };\n\n            const resourcePath = url.resolve(resource.url.replace(loader.baseUrl, ''), textureURL);\n            const resourceName = data.cacheID;\n\n            // The appropriate loader should register the texture\n            loader.add(resourceName, resourcePath, loadOptions, (res: LoaderResource) =>\n            {\n                if (res.error)\n                {\n                    next(res.error);\n\n                    return;\n                }\n\n                const { texture = null, textures = {} } = res;\n\n                // Make sure texture/textures is assigned to parent resource\n                Object.assign(resource, { texture, textures });\n\n                // Pass along any error\n                next();\n            });\n        }\n        else\n        {\n            next();\n        }\n    }\n\n    /**  Map of available texture extensions. */\n    public static get textureExtensions(): Partial<CompressedTextureExtensions>\n    {\n        if (!CompressedTextureLoader._textureExtensions)\n        {\n            // Auto-detect WebGL compressed-texture extensions\n            const canvas = settings.ADAPTER.createCanvas();\n            const gl = canvas.getContext('webgl');\n\n            if (!gl)\n            {\n                // #if _DEBUG\n                console.warn('WebGL not available for compressed textures. Silently failing.');\n                // #endif\n\n                return {};\n            }\n\n            const extensions = {\n                s3tc: gl.getExtension('WEBGL_compressed_texture_s3tc'),\n                s3tc_sRGB: gl.getExtension('WEBGL_compressed_texture_s3tc_srgb'), /* eslint-disable-line camelcase */\n                etc: gl.getExtension('WEBGL_compressed_texture_etc'),\n                etc1: gl.getExtension('WEBGL_compressed_texture_etc1'),\n                pvrtc: gl.getExtension('WEBGL_compressed_texture_pvrtc')\n                    || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc'),\n                atc: gl.getExtension('WEBGL_compressed_texture_atc'),\n                astc: gl.getExtension('WEBGL_compressed_texture_astc')\n            };\n\n            CompressedTextureLoader._textureExtensions = extensions;\n        }\n\n        return CompressedTextureLoader._textureExtensions;\n    }\n\n    /** Map of available texture formats. */\n    public static get textureFormats(): { [P in keyof INTERNAL_FORMATS]?: number }\n    {\n        if (!CompressedTextureLoader._textureFormats)\n        {\n            const extensions = CompressedTextureLoader.textureExtensions;\n\n            CompressedTextureLoader._textureFormats = {};\n\n            // Assign all available compressed-texture formats\n            for (const extensionName in extensions)\n            {\n                const extension = extensions[extensionName as CompressedTextureExtensionRef];\n\n                if (!extension)\n                {\n                    continue;\n                }\n\n                Object.assign(\n                    CompressedTextureLoader._textureFormats,\n                    Object.getPrototypeOf(extension));\n            }\n        }\n\n        return CompressedTextureLoader._textureFormats;\n    }\n}\n","import { MIPMAP_MODES, ALPHA_MODES } from '@pixi/constants';\nimport { BaseTexture, Texture } from '@pixi/core';\n\nimport type { LoaderResource, IResourceMetadata } from '@pixi/loaders';\nimport type { CompressedTextureResource } from '../resources/CompressedTextureResource';\n\n/**\n * Result when calling registerCompressedTextures.\n * @ignore\n */\ntype CompressedTexturesResult = Pick<LoaderResource, 'textures' | 'texture'>;\n\n/**\n * Creates base-textures and textures for each compressed-texture resource and adds them into the global\n * texture cache. The first texture has two IDs - `${url}`, `${url}-1`; while the rest have an ID of the\n * form `${url}-i`.\n * @param url - the original address of the resources\n * @param resources - the resources backing texture data\n * @ignore\n */\nexport function registerCompressedTextures(\n    url: string,\n    resources: CompressedTextureResource[],\n    metadata: IResourceMetadata\n): CompressedTexturesResult\n{\n    const result: CompressedTexturesResult = {\n        textures: {},\n        texture: null,\n    };\n\n    if (!resources)\n    {\n        return result;\n    }\n\n    const textures = resources.map((resource) =>\n        (\n            new Texture(new BaseTexture(resource, Object.assign({\n                mipmap: MIPMAP_MODES.OFF,\n                alphaMode: ALPHA_MODES.NO_PREMULTIPLIED_ALPHA\n            }, metadata)))\n        ));\n\n    textures.forEach((texture, i) =>\n    {\n        const { baseTexture } = texture;\n        const cacheID = `${url}-${i + 1}`;\n\n        BaseTexture.addToCache(baseTexture, cacheID);\n        Texture.addToCache(texture, cacheID);\n\n        if (i === 0)\n        {\n            BaseTexture.addToCache(baseTexture, url);\n            Texture.addToCache(texture, url);\n            result.texture = texture;\n        }\n\n        result.textures[cacheID] = texture;\n    });\n\n    return result;\n}\n","import { CompressedTextureResource } from '../resources';\nimport { INTERNAL_FORMATS, INTERNAL_FORMAT_TO_BYTES_PER_PIXEL } from '../const';\n\nconst DDS_MAGIC_SIZE = 4;\nconst DDS_HEADER_SIZE = 124;\nconst DDS_HEADER_PF_SIZE = 32;\nconst DDS_HEADER_DX10_SIZE = 20;\n\n// DDS file format magic word\nconst DDS_MAGIC = 0x20534444;\n\n/**\n * DWORD offsets of the DDS file header fields (relative to file start).\n * @ignore\n */\nconst DDS_FIELDS = {\n    SIZE: 1,\n    FLAGS: 2,\n    HEIGHT: 3,\n    WIDTH: 4,\n    MIPMAP_COUNT: 7,\n    PIXEL_FORMAT: 19,\n};\n\n/**\n * DWORD offsets of the DDS PIXEL_FORMAT fields.\n * @ignore\n */\nconst DDS_PF_FIELDS = {\n    SIZE: 0,\n    FLAGS: 1,\n    FOURCC: 2,\n    RGB_BITCOUNT: 3,\n    R_BIT_MASK: 4,\n    G_BIT_MASK: 5,\n    B_BIT_MASK: 6,\n    A_BIT_MASK: 7\n};\n\n/**\n * DWORD offsets of the DDS_HEADER_DX10 fields.\n * @ignore\n */\nconst DDS_DX10_FIELDS = {\n    DXGI_FORMAT: 0,\n    RESOURCE_DIMENSION: 1,\n    MISC_FLAG: 2,\n    ARRAY_SIZE: 3,\n    MISC_FLAGS2: 4\n};\n\n/**\n * @see https://docs.microsoft.com/en-us/windows/win32/api/dxgiformat/ne-dxgiformat-dxgi_format\n * @ignore\n */\n// This is way over-blown for us! Lend us a hand, and remove the ones that aren't used (but set the remaining\n// ones to their correct value)\nenum DXGI_FORMAT\n    {\n    DXGI_FORMAT_UNKNOWN,\n    DXGI_FORMAT_R32G32B32A32_TYPELESS,\n    DXGI_FORMAT_R32G32B32A32_FLOAT,\n    DXGI_FORMAT_R32G32B32A32_UINT,\n    DXGI_FORMAT_R32G32B32A32_SINT,\n    DXGI_FORMAT_R32G32B32_TYPELESS,\n    DXGI_FORMAT_R32G32B32_FLOAT,\n    DXGI_FORMAT_R32G32B32_UINT,\n    DXGI_FORMAT_R32G32B32_SINT,\n    DXGI_FORMAT_R16G16B16A16_TYPELESS,\n    DXGI_FORMAT_R16G16B16A16_FLOAT,\n    DXGI_FORMAT_R16G16B16A16_UNORM,\n    DXGI_FORMAT_R16G16B16A16_UINT,\n    DXGI_FORMAT_R16G16B16A16_SNORM,\n    DXGI_FORMAT_R16G16B16A16_SINT,\n    DXGI_FORMAT_R32G32_TYPELESS,\n    DXGI_FORMAT_R32G32_FLOAT,\n    DXGI_FORMAT_R32G32_UINT,\n    DXGI_FORMAT_R32G32_SINT,\n    DXGI_FORMAT_R32G8X24_TYPELESS,\n    DXGI_FORMAT_D32_FLOAT_S8X24_UINT,\n    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS,\n    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT,\n    DXGI_FORMAT_R10G10B10A2_TYPELESS,\n    DXGI_FORMAT_R10G10B10A2_UNORM,\n    DXGI_FORMAT_R10G10B10A2_UINT,\n    DXGI_FORMAT_R11G11B10_FLOAT,\n    DXGI_FORMAT_R8G8B8A8_TYPELESS,\n    DXGI_FORMAT_R8G8B8A8_UNORM,\n    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,\n    DXGI_FORMAT_R8G8B8A8_UINT,\n    DXGI_FORMAT_R8G8B8A8_SNORM,\n    DXGI_FORMAT_R8G8B8A8_SINT,\n    DXGI_FORMAT_R16G16_TYPELESS,\n    DXGI_FORMAT_R16G16_FLOAT,\n    DXGI_FORMAT_R16G16_UNORM,\n    DXGI_FORMAT_R16G16_UINT,\n    DXGI_FORMAT_R16G16_SNORM,\n    DXGI_FORMAT_R16G16_SINT,\n    DXGI_FORMAT_R32_TYPELESS,\n    DXGI_FORMAT_D32_FLOAT,\n    DXGI_FORMAT_R32_FLOAT,\n    DXGI_FORMAT_R32_UINT,\n    DXGI_FORMAT_R32_SINT,\n    DXGI_FORMAT_R24G8_TYPELESS,\n    DXGI_FORMAT_D24_UNORM_S8_UINT,\n    DXGI_FORMAT_R24_UNORM_X8_TYPELESS,\n    DXGI_FORMAT_X24_TYPELESS_G8_UINT,\n    DXGI_FORMAT_R8G8_TYPELESS,\n    DXGI_FORMAT_R8G8_UNORM,\n    DXGI_FORMAT_R8G8_UINT,\n    DXGI_FORMAT_R8G8_SNORM,\n    DXGI_FORMAT_R8G8_SINT,\n    DXGI_FORMAT_R16_TYPELESS,\n    DXGI_FORMAT_R16_FLOAT,\n    DXGI_FORMAT_D16_UNORM,\n    DXGI_FORMAT_R16_UNORM,\n    DXGI_FORMAT_R16_UINT,\n    DXGI_FORMAT_R16_SNORM,\n    DXGI_FORMAT_R16_SINT,\n    DXGI_FORMAT_R8_TYPELESS,\n    DXGI_FORMAT_R8_UNORM,\n    DXGI_FORMAT_R8_UINT,\n    DXGI_FORMAT_R8_SNORM,\n    DXGI_FORMAT_R8_SINT,\n    DXGI_FORMAT_A8_UNORM,\n    DXGI_FORMAT_R1_UNORM,\n    DXGI_FORMAT_R9G9B9E5_SHAREDEXP,\n    DXGI_FORMAT_R8G8_B8G8_UNORM,\n    DXGI_FORMAT_G8R8_G8B8_UNORM,\n    DXGI_FORMAT_BC1_TYPELESS,\n    DXGI_FORMAT_BC1_UNORM,\n    DXGI_FORMAT_BC1_UNORM_SRGB,\n    DXGI_FORMAT_BC2_TYPELESS,\n    DXGI_FORMAT_BC2_UNORM,\n    DXGI_FORMAT_BC2_UNORM_SRGB,\n    DXGI_FORMAT_BC3_TYPELESS,\n    DXGI_FORMAT_BC3_UNORM,\n    DXGI_FORMAT_BC3_UNORM_SRGB,\n    DXGI_FORMAT_BC4_TYPELESS,\n    DXGI_FORMAT_BC4_UNORM,\n    DXGI_FORMAT_BC4_SNORM,\n    DXGI_FORMAT_BC5_TYPELESS,\n    DXGI_FORMAT_BC5_UNORM,\n    DXGI_FORMAT_BC5_SNORM,\n    DXGI_FORMAT_B5G6R5_UNORM,\n    DXGI_FORMAT_B5G5R5A1_UNORM,\n    DXGI_FORMAT_B8G8R8A8_UNORM,\n    DXGI_FORMAT_B8G8R8X8_UNORM,\n    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM,\n    DXGI_FORMAT_B8G8R8A8_TYPELESS,\n    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,\n    DXGI_FORMAT_B8G8R8X8_TYPELESS,\n    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB,\n    DXGI_FORMAT_BC6H_TYPELESS,\n    DXGI_FORMAT_BC6H_UF16,\n    DXGI_FORMAT_BC6H_SF16,\n    DXGI_FORMAT_BC7_TYPELESS,\n    DXGI_FORMAT_BC7_UNORM,\n    DXGI_FORMAT_BC7_UNORM_SRGB,\n    DXGI_FORMAT_AYUV,\n    DXGI_FORMAT_Y410,\n    DXGI_FORMAT_Y416,\n    DXGI_FORMAT_NV12,\n    DXGI_FORMAT_P010,\n    DXGI_FORMAT_P016,\n    DXGI_FORMAT_420_OPAQUE,\n    DXGI_FORMAT_YUY2,\n    DXGI_FORMAT_Y210,\n    DXGI_FORMAT_Y216,\n    DXGI_FORMAT_NV11,\n    DXGI_FORMAT_AI44,\n    DXGI_FORMAT_IA44,\n    DXGI_FORMAT_P8,\n    DXGI_FORMAT_A8P8,\n    DXGI_FORMAT_B4G4R4A4_UNORM,\n    DXGI_FORMAT_P208,\n    DXGI_FORMAT_V208,\n    DXGI_FORMAT_V408,\n    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE,\n    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE,\n    DXGI_FORMAT_FORCE_UINT\n}\n\n/**\n * Possible values of the field {@link DDS_DX10_FIELDS.RESOURCE_DIMENSION}\n * @ignore\n */\nenum D3D10_RESOURCE_DIMENSION\n    {\n    DDS_DIMENSION_TEXTURE1D = 2,\n    DDS_DIMENSION_TEXTURE2D = 3,\n    DDS_DIMENSION_TEXTURE3D = 6\n}\n\nconst PF_FLAGS = 1;\n\n// PIXEL_FORMAT flags\nconst DDPF_ALPHA = 0x2;\nconst DDPF_FOURCC = 0x4;\nconst DDPF_RGB = 0x40;\nconst DDPF_YUV = 0x200;\nconst DDPF_LUMINANCE = 0x20000;\n\n// Four character codes for DXTn formats\nconst FOURCC_DXT1 = 0x31545844;\nconst FOURCC_DXT3 = 0x33545844;\nconst FOURCC_DXT5 = 0x35545844;\nconst FOURCC_DX10 = 0x30315844;\n\n// Cubemap texture flag (for DDS_DX10_FIELDS.MISC_FLAG)\nconst DDS_RESOURCE_MISC_TEXTURECUBE = 0x4;\n\n/**\n * Maps `FOURCC_*` formats to internal formats (see {@link PIXI.INTERNAL_FORMATS}).\n * @ignore\n */\nconst FOURCC_TO_FORMAT: { [id: number]: number } = {\n    [FOURCC_DXT1]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,\n    [FOURCC_DXT3]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,\n    [FOURCC_DXT5]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT\n};\n\n/**\n * Maps {@link DXGI_FORMAT} to types/internal-formats (see {@link PIXI.TYPES}, {@link PIXI.INTERNAL_FORMATS})\n * @ignore\n */\nconst DXGI_TO_FORMAT: { [id: number]: number } = {\n    // WEBGL_compressed_texture_s3tc\n    [DXGI_FORMAT.DXGI_FORMAT_BC1_TYPELESS]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT1_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC2_TYPELESS]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT3_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC3_TYPELESS]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM]: INTERNAL_FORMATS.COMPRESSED_RGBA_S3TC_DXT5_EXT,\n\n    // WEBGL_compressed_texture_s3tc_srgb\n    [DXGI_FORMAT.DXGI_FORMAT_BC1_UNORM_SRGB]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC2_UNORM_SRGB]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,\n    [DXGI_FORMAT.DXGI_FORMAT_BC3_UNORM_SRGB]: INTERNAL_FORMATS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT\n};\n\n/**\n * @class\n * @memberof PIXI\n * @implements {PIXI.ILoaderPlugin}\n * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide\n */\n/**\n * Parses the DDS file header, generates base-textures, and puts them into the texture cache.\n * @param arrayBuffer\n */\nexport function parseDDS(arrayBuffer: ArrayBuffer): CompressedTextureResource[]\n{\n    const data = new Uint32Array(arrayBuffer);\n    const magicWord = data[0];\n\n    if (magicWord !== DDS_MAGIC)\n    {\n        throw new Error('Invalid DDS file magic word');\n    }\n\n    const header = new Uint32Array(arrayBuffer, 0, DDS_HEADER_SIZE / Uint32Array.BYTES_PER_ELEMENT);\n\n    // DDS header fields\n    const height = header[DDS_FIELDS.HEIGHT];\n    const width = header[DDS_FIELDS.WIDTH];\n    const mipmapCount = header[DDS_FIELDS.MIPMAP_COUNT];\n\n    // PIXEL_FORMAT fields\n    const pixelFormat = new Uint32Array(\n        arrayBuffer,\n        DDS_FIELDS.PIXEL_FORMAT * Uint32Array.BYTES_PER_ELEMENT,\n        DDS_HEADER_PF_SIZE / Uint32Array.BYTES_PER_ELEMENT);\n    const formatFlags = pixelFormat[PF_FLAGS];\n\n    // File contains compressed texture(s)\n    if (formatFlags & DDPF_FOURCC)\n    {\n        const fourCC = pixelFormat[DDS_PF_FIELDS.FOURCC];\n\n        // File contains one DXTn compressed texture\n        if (fourCC !== FOURCC_DX10)\n        {\n            const internalFormat = FOURCC_TO_FORMAT[fourCC];\n\n            const dataOffset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;\n            const texData = new Uint8Array(arrayBuffer, dataOffset);\n\n            const resource = new CompressedTextureResource(texData, {\n                format: internalFormat,\n                width,\n                height,\n                levels: mipmapCount // CompressedTextureResource will separate the levelBuffers for us!\n            });\n\n            return [resource];\n        }\n\n        // FOURCC_DX10 indicates there is a 20-byte DDS_HEADER_DX10 after DDS_HEADER\n        const dx10Offset = DDS_MAGIC_SIZE + DDS_HEADER_SIZE;\n        const dx10Header = new Uint32Array(\n            data.buffer,\n            dx10Offset,\n            DDS_HEADER_DX10_SIZE / Uint32Array.BYTES_PER_ELEMENT);\n        const dxgiFormat = dx10Header[DDS_DX10_FIELDS.DXGI_FORMAT];\n        const resourceDimension = dx10Header[DDS_DX10_FIELDS.RESOURCE_DIMENSION];\n        const miscFlag = dx10Header[DDS_DX10_FIELDS.MISC_FLAG];\n        const arraySize = dx10Header[DDS_DX10_FIELDS.ARRAY_SIZE];\n\n        // Map dxgiFormat to PIXI.INTERNAL_FORMATS\n        const internalFormat = DXGI_TO_FORMAT[dxgiFormat];\n\n        if (internalFormat === undefined)\n        {\n            throw new Error(`DDSParser cannot parse texture data with DXGI format ${dxgiFormat}`);\n        }\n        if (miscFlag === DDS_RESOURCE_MISC_TEXTURECUBE)\n        {\n            // FIXME: Anybody excited about cubemap compressed textures?\n            throw new Error('DDSParser does not support cubemap textures');\n        }\n        if (resourceDimension === D3D10_RESOURCE_DIMENSION.DDS_DIMENSION_TEXTURE3D)\n        {\n            // FIXME: Anybody excited about 3D compressed textures?\n            throw new Error('DDSParser does not supported 3D texture data');\n        }\n\n        // Uint8Array buffers of image data, including all mipmap levels in each image\n        const imageBuffers = new Array<Uint8Array>();\n        const dataOffset = DDS_MAGIC_SIZE\n                + DDS_HEADER_SIZE\n                + DDS_HEADER_DX10_SIZE;\n\n        if (arraySize === 1)\n        {\n            // No need bothering with the imageSize calculation!\n            imageBuffers.push(new Uint8Array(arrayBuffer, dataOffset));\n        }\n        else\n        {\n            // Calculate imageSize for each texture, and then locate each image's texture data\n\n            const pixelSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[internalFormat];\n            let imageSize = 0;\n            let levelWidth = width;\n            let levelHeight = height;\n\n            for (let i = 0; i < mipmapCount; i++)\n            {\n                const alignedLevelWidth = Math.max(1, (levelWidth + 3) & ~3);\n                const alignedLevelHeight = Math.max(1, (levelHeight + 3) & ~3);\n\n                const levelSize = alignedLevelWidth * alignedLevelHeight * pixelSize;\n\n                imageSize += levelSize;\n\n                levelWidth = levelWidth >>> 1;\n                levelHeight = levelHeight >>> 1;\n            }\n\n            let imageOffset = dataOffset;\n\n            // NOTE: Cubemaps have 6-images per texture (but they aren't supported so ^_^)\n            for (let i = 0; i < arraySize; i++)\n            {\n                imageBuffers.push(new Uint8Array(arrayBuffer, imageOffset, imageSize));\n                imageOffset += imageSize;\n            }\n        }\n\n        // Uint8Array -> CompressedTextureResource, and we're done!\n        return imageBuffers.map((buffer) => new CompressedTextureResource(buffer, {\n            format: internalFormat,\n            width,\n            height,\n            levels: mipmapCount\n        }));\n    }\n    if (formatFlags & DDPF_RGB)\n    {\n        // FIXME: We might want to allow uncompressed *.dds files?\n        throw new Error('DDSParser does not support uncompressed texture data.');\n    }\n    if (formatFlags & DDPF_YUV)\n    {\n        // FIXME: Does anybody need this feature?\n        throw new Error('DDSParser does not supported YUV uncompressed texture data.');\n    }\n    if (formatFlags & DDPF_LUMINANCE)\n    {\n        // FIXME: Microsoft says older DDS filers use this feature! Probably not worth the effort!\n        throw new Error('DDSParser does not support single-channel (lumninance) texture data!');\n    }\n    if (formatFlags & DDPF_ALPHA)\n    {\n        // FIXME: I'm tired! See above =)\n        throw new Error('DDSParser does not support single-channel (alpha) texture data!');\n    }\n\n    throw new Error('DDSParser failed to load a texture file due to an unknown reason!');\n}\n\n","import { FORMATS, TYPES } from '@pixi/constants';\nimport { BufferResource } from '@pixi/core';\n\nimport { INTERNAL_FORMAT_TO_BYTES_PER_PIXEL } from '../const';\nimport type { CompressedLevelBuffer } from '../resources';\nimport { CompressedTextureResource } from '../resources';\n\n/**\n * The 12-byte KTX file identifier\n * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.1\n * @ignore\n */\nconst FILE_IDENTIFIER = [0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A];\n\n/**\n * The value stored in the \"endianness\" field.\n * @see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/#2.2\n * @ignore\n */\nconst ENDIANNESS = 0x04030201;\n\n/**\n * Byte offsets of the KTX file header fields\n * @ignore\n */\nconst KTX_FIELDS = {\n    FILE_IDENTIFIER: 0,\n    ENDIANNESS: 12,\n    GL_TYPE: 16,\n    GL_TYPE_SIZE: 20,\n    GL_FORMAT: 24,\n    GL_INTERNAL_FORMAT: 28,\n    GL_BASE_INTERNAL_FORMAT: 32,\n    PIXEL_WIDTH: 36,\n    PIXEL_HEIGHT: 40,\n    PIXEL_DEPTH: 44,\n    NUMBER_OF_ARRAY_ELEMENTS: 48,\n    NUMBER_OF_FACES: 52,\n    NUMBER_OF_MIPMAP_LEVELS: 56,\n    BYTES_OF_KEY_VALUE_DATA: 60\n};\n\n/**\n * Byte size of the file header fields in {@code KTX_FIELDS}\n * @ignore\n */\nconst FILE_HEADER_SIZE = 64;\n\n/**\n * Maps {@link PIXI.TYPES} to the bytes taken per component, excluding those ones that are bit-fields.\n * @ignore\n */\nexport const TYPES_TO_BYTES_PER_COMPONENT: { [id: number]: number } = {\n    [TYPES.UNSIGNED_BYTE]: 1,\n    [TYPES.UNSIGNED_SHORT]: 2,\n    [TYPES.INT]: 4,\n    [TYPES.UNSIGNED_INT]: 4,\n    [TYPES.FLOAT]: 4,\n    [TYPES.HALF_FLOAT]: 8\n};\n\n/**\n * Number of components in each {@link PIXI.FORMATS}\n * @ignore\n */\nexport const FORMATS_TO_COMPONENTS: { [id: number]: number } = {\n    [FORMATS.RGBA]: 4,\n    [FORMATS.RGB]: 3,\n    [FORMATS.RG]: 2,\n    [FORMATS.RED]: 1,\n    [FORMATS.LUMINANCE]: 1,\n    [FORMATS.LUMINANCE_ALPHA]: 2,\n    [FORMATS.ALPHA]: 1\n};\n\n/**\n * Number of bytes per pixel in bit-field types in {@link PIXI.TYPES}\n * @ignore\n */\nexport const TYPES_TO_BYTES_PER_PIXEL: { [id: number]: number } = {\n    [TYPES.UNSIGNED_SHORT_4_4_4_4]: 2,\n    [TYPES.UNSIGNED_SHORT_5_5_5_1]: 2,\n    [TYPES.UNSIGNED_SHORT_5_6_5]: 2\n};\n\nexport function parseKTX(url: string, arrayBuffer: ArrayBuffer, loadKeyValueData = false): {\n    compressed?: CompressedTextureResource[]\n    uncompressed?: { resource: BufferResource, type: TYPES, format: FORMATS }[]\n    kvData: Map<string, DataView> | null\n}\n{\n    const dataView = new DataView(arrayBuffer);\n\n    if (!validate(url, dataView))\n    {\n        return null;\n    }\n\n    const littleEndian = dataView.getUint32(KTX_FIELDS.ENDIANNESS, true) === ENDIANNESS;\n    const glType = dataView.getUint32(KTX_FIELDS.GL_TYPE, littleEndian);\n    // const glTypeSize = dataView.getUint32(KTX_FIELDS.GL_TYPE_SIZE, littleEndian);\n    const glFormat = dataView.getUint32(KTX_FIELDS.GL_FORMAT, littleEndian);\n    const glInternalFormat = dataView.getUint32(KTX_FIELDS.GL_INTERNAL_FORMAT, littleEndian);\n    const pixelWidth = dataView.getUint32(KTX_FIELDS.PIXEL_WIDTH, littleEndian);\n    const pixelHeight = dataView.getUint32(KTX_FIELDS.PIXEL_HEIGHT, littleEndian) || 1;// \"pixelHeight = 0\" -> \"1\"\n    const pixelDepth = dataView.getUint32(KTX_FIELDS.PIXEL_DEPTH, littleEndian) || 1;// ^^\n    const numberOfArrayElements = dataView.getUint32(KTX_FIELDS.NUMBER_OF_ARRAY_ELEMENTS, littleEndian) || 1;// ^^\n    const numberOfFaces = dataView.getUint32(KTX_FIELDS.NUMBER_OF_FACES, littleEndian);\n    const numberOfMipmapLevels = dataView.getUint32(KTX_FIELDS.NUMBER_OF_MIPMAP_LEVELS, littleEndian);\n    const bytesOfKeyValueData = dataView.getUint32(KTX_FIELDS.BYTES_OF_KEY_VALUE_DATA, littleEndian);\n\n    // Whether the platform architecture is little endian. If littleEndian !== platformLittleEndian, then the\n    // file contents must be endian-converted!\n    // TODO: Endianness conversion\n    // const platformLittleEndian = new Uint8Array((new Uint32Array([ENDIANNESS])).buffer)[0] === 0x01;\n\n    if (pixelHeight === 0 || pixelDepth !== 1)\n    {\n        throw new Error('Only 2D textures are supported');\n    }\n    if (numberOfFaces !== 1)\n    {\n        throw new Error('CubeTextures are not supported by KTXLoader yet!');\n    }\n    if (numberOfArrayElements !== 1)\n    {\n        // TODO: Support splitting array-textures into multiple BaseTextures\n        throw new Error('WebGL does not support array textures');\n    }\n\n    // TODO: 8x4 blocks for 2bpp pvrtc\n    const blockWidth = 4;\n    const blockHeight = 4;\n\n    const alignedWidth = (pixelWidth + 3) & ~3;\n    const alignedHeight = (pixelHeight + 3) & ~3;\n    const imageBuffers = new Array<CompressedLevelBuffer[]>(numberOfArrayElements);\n    let imagePixels = pixelWidth * pixelHeight;\n\n    if (glType === 0)\n    {\n        // Align to 16 pixels (4x4 blocks)\n        imagePixels = alignedWidth * alignedHeight;\n    }\n\n    let imagePixelByteSize: number;\n\n    if (glType !== 0)\n    {\n        // Uncompressed texture format\n        if (TYPES_TO_BYTES_PER_COMPONENT[glType])\n        {\n            imagePixelByteSize = TYPES_TO_BYTES_PER_COMPONENT[glType] * FORMATS_TO_COMPONENTS[glFormat];\n        }\n        else\n        {\n            imagePixelByteSize = TYPES_TO_BYTES_PER_PIXEL[glType];\n        }\n    }\n    else\n    {\n        imagePixelByteSize = INTERNAL_FORMAT_TO_BYTES_PER_PIXEL[glInternalFormat];\n    }\n\n    if (imagePixelByteSize === undefined)\n    {\n        throw new Error('Unable to resolve the pixel format stored in the *.ktx file!');\n    }\n\n    const kvData: Map<string, DataView> | null = loadKeyValueData\n        ? parseKvData(dataView, bytesOfKeyValueData, littleEndian)\n        : null;\n\n    const imageByteSize = imagePixels * imagePixelByteSize;\n    let mipByteSize = imageByteSize;\n    let mipWidth = pixelWidth;\n    let mipHeight = pixelHeight;\n    let alignedMipWidth = alignedWidth;\n    let alignedMipHeight = alignedHeight;\n    let imageOffset = FILE_HEADER_SIZE + bytesOfKeyValueData;\n\n    for (let mipmapLevel = 0; mipmapLevel < numberOfMipmapLevels; mipmapLevel++)\n    {\n        const imageSize = dataView.getUint32(imageOffset, littleEndian);\n        let elementOffset = imageOffset + 4;\n\n        for (let arrayElement = 0; arrayElement < numberOfArrayElements; arrayElement++)\n        {\n            // TODO: Maybe support 3D textures? :-)\n            // for (let zSlice = 0; zSlice < pixelDepth; zSlice)\n\n            let mips = imageBuffers[arrayElement];\n\n            if (!mips)\n            {\n                mips = imageBuffers[arrayElement] = new Array(numberOfMipmapLevels);\n            }\n\n            mips[mipmapLevel] = {\n                levelID: mipmapLevel,\n\n                // don't align mipWidth when texture not compressed! (glType not zero)\n                levelWidth: numberOfMipmapLevels > 1 || glType !== 0 ? mipWidth : alignedMipWidth,\n                levelHeight: numberOfMipmapLevels > 1 || glType !== 0 ? mipHeight : alignedMipHeight,\n                levelBuffer: new Uint8Array(arrayBuffer, elementOffset, mipByteSize)\n            };\n            elementOffset += mipByteSize;\n        }\n\n        // HINT: Aligns to 4-byte boundary after jumping imageSize (in lieu of mipPadding)\n        imageOffset += imageSize + 4;// (+4 to jump the imageSize field itself)\n        imageOffset = imageOffset % 4 !== 0 ? imageOffset + 4 - (imageOffset % 4) : imageOffset;\n\n        // Calculate mipWidth, mipHeight for _next_ iteration\n        mipWidth = (mipWidth >> 1) || 1;\n        mipHeight = (mipHeight >> 1) || 1;\n        alignedMipWidth = (mipWidth + blockWidth - 1) & ~(blockWidth - 1);\n        alignedMipHeight = (mipHeight + blockHeight - 1) & ~(blockHeight - 1);\n\n        // Each mipmap level is 4-times smaller?\n        mipByteSize = alignedMipWidth * alignedMipHeight * imagePixelByteSize;\n    }\n\n    // We use the levelBuffers feature of CompressedTextureResource b/c texture data is image-major, not level-major.\n    if (glType !== 0)\n    {\n        return {\n            uncompressed: imageBuffers.map((levelBuffers) =>\n            {\n                let buffer: Float32Array | Uint32Array | Int32Array | Uint8Array = levelBuffers[0].levelBuffer;\n                let convertToInt = false;\n\n                if (glType === TYPES.FLOAT)\n                {\n                    buffer = new Float32Array(\n                        levelBuffers[0].levelBuffer.buffer,\n                        levelBuffers[0].levelBuffer.byteOffset,\n                        levelBuffers[0].levelBuffer.byteLength / 4);\n                }\n                else if (glType === TYPES.UNSIGNED_INT)\n                {\n                    convertToInt = true;\n                    buffer = new Uint32Array(\n                        levelBuffers[0].levelBuffer.buffer,\n                        levelBuffers[0].levelBuffer.byteOffset,\n                        levelBuffers[0].levelBuffer.byteLength / 4);\n                }\n                else if (glType === TYPES.INT)\n                {\n                    convertToInt = true;\n                    buffer = new Int32Array(\n                        levelBuffers[0].levelBuffer.buffer,\n                        levelBuffers[0].levelBuffer.byteOffset,\n                        levelBuffers[0].levelBuffer.byteLength / 4);\n                }\n\n                return {\n                    resource: new BufferResource(\n                        buffer,\n                        {\n                            width: levelBuffers[0].levelWidth,\n                            height: levelBuffers[0].levelHeight,\n                        }\n                    ),\n                    type: glType,\n                    format: convertToInt ? convertFormatToInteger(glFormat) : glFormat,\n                };\n            }),\n            kvData\n        };\n    }\n\n    return {\n        compressed: imageBuffers.map((levelBuffers) => new CompressedTextureResource(null, {\n            format: glInternalFormat,\n            width: pixelWidth,\n            height: pixelHeight,\n            levels: numberOfMipmapLevels,\n            levelBuffers,\n        })),\n        kvData\n    };\n}\n\n/**\n * Checks whether the arrayBuffer contains a valid *.ktx file.\n * @param url\n * @param dataView\n */\nfunction validate(url: string, dataView: DataView): boolean\n{\n    // NOTE: Do not optimize this into 3 32-bit integer comparison because the endianness\n    // of the data is not specified.\n    for (let i = 0; i < FILE_IDENTIFIER.length; i++)\n    {\n        if (dataView.getUint8(i) !== FILE_IDENTIFIER[i])\n        {\n            // #if _DEBUG\n            console.error(`${url} is not a valid *.ktx file!`);\n            // #endif\n\n            return false;\n        }\n    }\n\n    return true;\n}\n\nfunction convertFormatToInteger(format: FORMATS)\n{\n    switch (format)\n    {\n        case FORMATS.RGBA: return FORMATS.RGBA_INTEGER;\n        case FORMATS.RGB: return FORMATS.RGB_INTEGER;\n        case FORMATS.RG: return FORMATS.RG_INTEGER;\n        case FORMATS.RED: return FORMATS.RED_INTEGER;\n        default: return format;\n    }\n}\n\nfunction parseKvData(dataView: DataView, bytesOfKeyValueData: number, littleEndian: boolean): Map<string, DataView>\n{\n    const kvData = new Map<string, DataView>();\n    let bytesIntoKeyValueData = 0;\n\n    while (bytesIntoKeyValueData < bytesOfKeyValueData)\n    {\n        const keyAndValueByteSize = dataView.getUint32(FILE_HEADER_SIZE + bytesIntoKeyValueData, littleEndian);\n        const keyAndValueByteOffset = FILE_HEADER_SIZE + bytesIntoKeyValueData + 4;\n        const valuePadding = 3 - ((keyAndValueByteSize + 3) % 4);\n\n        // Bounds check\n        if (keyAndValueByteSize === 0 || keyAndValueByteSize > bytesOfKeyValueData - bytesIntoKeyValueData)\n        {\n            console.error('KTXLoader: keyAndValueByteSize out of bounds');\n            break;\n        }\n\n        // Note: keyNulByte can't be 0 otherwise the key is an empty string.\n        let keyNulByte = 0;\n\n        for (; keyNulByte < keyAndValueByteSize; keyNulByte++)\n        {\n            if (dataView.getUint8(keyAndValueByteOffset + keyNulByte) === 0x00)\n            {\n                break;\n            }\n        }\n\n        if (keyNulByte === -1)\n        {\n            console.error('KTXLoader: Failed to find null byte terminating kvData key');\n            break;\n        }\n\n        const key = new TextDecoder().decode(\n            new Uint8Array(dataView.buffer, keyAndValueByteOffset, keyNulByte)\n        );\n        const value = new DataView(\n            dataView.buffer,\n            keyAndValueByteOffset + keyNulByte + 1,\n            keyAndValueByteSize - keyNulByte - 1,\n        );\n\n        kvData.set(key, value);\n\n        // 4 = the keyAndValueByteSize field itself\n        // keyAndValueByteSize = the bytes taken by the key and value\n        // valuePadding = extra padding to align with 4 bytes\n        bytesIntoKeyValueData += 4 + keyAndValueByteSize + valuePadding;\n    }\n\n    return kvData;\n}\n","import { LoaderResource } from '@pixi/loaders';\nimport { registerCompressedTextures } from './registerCompressedTextures';\nimport type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\nimport { parseDDS } from '../parsers';\n\n// Set DDS files to be loaded as an ArrayBuffer\nLoaderResource.setExtensionXhrType('dds', LoaderResource.XHR_RESPONSE_TYPE.BUFFER);\n\n/**\n * @class\n * @memberof PIXI\n * @implements {PIXI.ILoaderPlugin}\n * @see https://docs.microsoft.com/en-us/windows/win32/direct3ddds/dx-graphics-dds-pguide\n */\nexport class DDSLoader\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Loader;\n\n    /**\n     * Registers a DDS compressed texture\n     * @see PIXI.Loader.loaderMiddleware\n     * @param resource - loader resource that is checked to see if it is a DDS file\n     * @param next - callback Function to call when done\n     */\n    public static use(resource: LoaderResource, next: (...args: any[]) => void): void\n    {\n        if (resource.extension === 'dds' && resource.data)\n        {\n            try\n            {\n                Object.assign(resource, registerCompressedTextures(\n                    resource.name || resource.url,\n                    parseDDS(resource.data),\n                    resource.metadata,\n                ));\n            }\n            catch (err)\n            {\n                next(err);\n\n                return;\n            }\n        }\n\n        next();\n    }\n}\n","import { ALPHA_MODES, MIPMAP_MODES } from '@pixi/constants';\nimport type { ExtensionMetadata } from '@pixi/core';\nimport { BaseTexture, ExtensionType, Texture } from '@pixi/core';\nimport { LoaderResource } from '@pixi/loaders';\nimport { registerCompressedTextures } from './registerCompressedTextures';\nimport { parseKTX } from '../parsers';\n\n// Set KTX files to be loaded as an ArrayBuffer\nLoaderResource.setExtensionXhrType('ktx', LoaderResource.XHR_RESPONSE_TYPE.BUFFER);\n\n/**\n * Loader plugin for handling KTX texture container files.\n *\n * This KTX loader does not currently support the following features:\n * * cube textures\n * * 3D textures\n * * endianness conversion for big-endian machines\n * * embedded *.basis files\n *\n * It does supports the following features:\n * * multiple textures per file\n * * mipmapping (only for compressed formats)\n * * vendor-specific key/value data parsing (enable {@link PIXI.KTXLoader.loadKeyValueData})\n * @class\n * @memberof PIXI\n * @implements {PIXI.ILoaderPlugin}\n */\nexport class KTXLoader\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Loader;\n\n    /**\n     * If set to `true`, {@link PIXI.KTXLoader} will parse key-value data in KTX textures. This feature relies\n     * on the [Encoding Standard]{@link https://encoding.spec.whatwg.org}.\n     *\n     * The key-value data will be available on the base-textures as {@code PIXI.BaseTexture.ktxKeyValueData}. They\n     * will hold a reference to the texture data buffer, so make sure to delete key-value data once you are done\n     * using it.\n     */\n    static loadKeyValueData = false;\n\n    /**\n     * Called after a KTX file is loaded.\n     *\n     * This will parse the KTX file header and add a {@code BaseTexture} to the texture\n     * cache.\n     * @see PIXI.Loader.loaderMiddleware\n     * @param resource - loader resource that is checked to see if it is a KTX file\n     * @param next - callback Function to call when done\n     */\n    public static use(resource: LoaderResource, next: (...args: any[]) => void): void\n    {\n        if (resource.extension === 'ktx' && resource.data)\n        {\n            try\n            {\n                const url = resource.name || resource.url;\n                const { compressed, uncompressed, kvData } = parseKTX(url, resource.data, this.loadKeyValueData);\n\n                if (compressed)\n                {\n                    const result = registerCompressedTextures(\n                        url,\n                        compressed,\n                        resource.metadata,\n                    );\n\n                    if (kvData && result.textures)\n                    {\n                        for (const textureId in result.textures)\n                        {\n                            result.textures[textureId].baseTexture.ktxKeyValueData = kvData;\n                        }\n                    }\n\n                    Object.assign(resource, result);\n                }\n                else if (uncompressed)\n                {\n                    const textures: Record<string, Texture> = {};\n\n                    uncompressed.forEach((image, i) =>\n                    {\n                        const texture = new Texture(new BaseTexture(\n                            image.resource,\n                            {\n                                mipmap: MIPMAP_MODES.OFF,\n                                alphaMode: ALPHA_MODES.NO_PREMULTIPLIED_ALPHA,\n                                type: image.type,\n                                format: image.format,\n                            }\n                        ));\n                        const cacheID = `${url}-${i + 1}`;\n\n                        if (kvData) texture.baseTexture.ktxKeyValueData = kvData;\n\n                        BaseTexture.addToCache(texture.baseTexture, cacheID);\n                        Texture.addToCache(texture, cacheID);\n\n                        if (i === 0)\n                        {\n                            textures[url] = texture;\n                            BaseTexture.addToCache(texture.baseTexture, url);\n                            Texture.addToCache(texture, url);\n                        }\n\n                        textures[cacheID] = texture;\n                    });\n\n                    Object.assign(resource, { textures });\n                }\n            }\n            catch (err)\n            {\n                next(err);\n\n                return;\n            }\n        }\n\n        next();\n    }\n}\n","import { BLEND_MODES } from '@pixi/constants';\nimport { Container } from '@pixi/display';\nimport { hex2rgb } from '@pixi/utils';\n\nimport type { BaseTexture, Renderer } from '@pixi/core';\nimport type { ParticleBuffer } from './ParticleBuffer';\nimport type { IDestroyOptions } from '@pixi/display';\nimport type { Sprite } from '@pixi/sprite';\n\nexport interface IParticleProperties\n{\n    vertices?: boolean;\n    position?: boolean;\n    rotation?: boolean;\n    uvs?: boolean;\n    tint?: boolean;\n    alpha?: boolean;\n    scale?: boolean;\n}\n\n/**\n * The ParticleContainer class is a really fast version of the Container built solely for speed,\n * so use when you need a lot of sprites or particles.\n *\n * The tradeoff of the ParticleContainer is that most advanced functionality will not work.\n * ParticleContainer implements the basic object transform (position, scale, rotation)\n * and some advanced functionality like tint (as of v4.5.6).\n *\n * Other more advanced functionality like masking, children, filters, etc will not work on sprites in this batch.\n *\n * It's extremely easy to use:\n * ```js\n * let container = new ParticleContainer();\n *\n * for (let i = 0; i < 100; ++i)\n * {\n *     let sprite = PIXI.Sprite.from(\"myImage.png\");\n *     container.addChild(sprite);\n * }\n * ```\n *\n * And here you have a hundred sprites that will be rendered at the speed of light.\n * @memberof PIXI\n */\nexport class ParticleContainer extends Container<Sprite>\n{\n    /**\n     * The blend mode to be applied to the sprite. Apply a value of `PIXI.BLEND_MODES.NORMAL`\n     * to reset the blend mode.\n     * @default PIXI.BLEND_MODES.NORMAL\n     */\n    public blendMode: BLEND_MODES;\n\n    /**\n     * If true, container allocates more batches in case there are more than `maxSize` particles.\n     * @default false\n     */\n    public autoResize: boolean;\n\n    /**\n     * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.\n     * Advantages can include sharper image quality (like text) and faster rendering on canvas.\n     * The main disadvantage is movement of objects may appear less smooth.\n     * Default to true here as performance is usually the priority for particles.\n     * @default true\n     */\n    public roundPixels: boolean;\n\n    /**\n     * The texture used to render the children.\n     * @readonly\n     */\n    public baseTexture: BaseTexture;\n    public tintRgb: Float32Array;\n\n    /** @private */\n    _maxSize: number;\n\n    /** @private */\n    _buffers: ParticleBuffer[];\n\n    /** @private */\n    _batchSize: number;\n\n    /**\n     * Set properties to be dynamic (true) / static (false).\n     * @private\n     */\n    _properties: boolean[];\n\n    /**\n     * For every batch, stores _updateID corresponding to the last change in that batch.\n     * @private\n     */\n    _bufferUpdateIDs: number[];\n\n    /**\n     * When child inserted, removed or changes position this number goes up.\n     * @private\n     */\n    _updateID: number;\n\n    /**\n     * The tint applied to the container.\n     * This is a hex value. A value of 0xFFFFFF will remove any tint effect.\n     * @default 0xFFFFFF\n     */\n    private _tint: number;\n\n    /**\n     * @param maxSize - The maximum number of particles that can be rendered by the container.\n     *  Affects size of allocated buffers.\n     * @param properties - The properties of children that should be uploaded to the gpu and applied.\n     * @param {boolean} [properties.vertices=false] - When true, vertices be uploaded and applied.\n     *                  if sprite's ` scale/anchor/trim/frame/orig` is dynamic, please set `true`.\n     * @param {boolean} [properties.position=true] - When true, position be uploaded and applied.\n     * @param {boolean} [properties.rotation=false] - When true, rotation be uploaded and applied.\n     * @param {boolean} [properties.uvs=false] - When true, uvs be uploaded and applied.\n     * @param {boolean} [properties.tint=false] - When true, alpha and tint be uploaded and applied.\n     * @param {number} [batchSize=16384] - Number of particles per batch. If less than maxSize, it uses maxSize instead.\n     * @param {boolean} [autoResize=false] - If true, container allocates more batches in case\n     *  there are more than `maxSize` particles.\n     */\n    constructor(maxSize = 1500, properties?: IParticleProperties, batchSize = 16384, autoResize = false)\n    {\n        super();\n\n        // Making sure the batch size is valid\n        // 65535 is max vertex index in the index buffer (see ParticleRenderer)\n        // so max number of particles is 65536 / 4 = 16384\n        const maxBatchSize = 16384;\n\n        if (batchSize > maxBatchSize)\n        {\n            batchSize = maxBatchSize;\n        }\n\n        this._properties = [false, true, false, false, false];\n        this._maxSize = maxSize;\n        this._batchSize = batchSize;\n        this._buffers = null;\n        this._bufferUpdateIDs = [];\n        this._updateID = 0;\n\n        this.interactiveChildren = false;\n        this.blendMode = BLEND_MODES.NORMAL;\n        this.autoResize = autoResize;\n        this.roundPixels = true;\n        this.baseTexture = null;\n\n        this.setProperties(properties);\n\n        this._tint = 0;\n        this.tintRgb = new Float32Array(4);\n        this.tint = 0xFFFFFF;\n    }\n\n    /**\n     * Sets the private properties array to dynamic / static based on the passed properties object\n     * @param properties - The properties to be uploaded\n     */\n    public setProperties(properties: IParticleProperties): void\n    {\n        if (properties)\n        {\n            this._properties[0] = 'vertices' in properties || 'scale' in properties\n                ? !!properties.vertices || !!properties.scale : this._properties[0];\n            this._properties[1] = 'position' in properties ? !!properties.position : this._properties[1];\n            this._properties[2] = 'rotation' in properties ? !!properties.rotation : this._properties[2];\n            this._properties[3] = 'uvs' in properties ? !!properties.uvs : this._properties[3];\n            this._properties[4] = 'tint' in properties || 'alpha' in properties\n                ? !!properties.tint || !!properties.alpha : this._properties[4];\n        }\n    }\n\n    updateTransform(): void\n    {\n        // TODO don't need to!\n        this.displayObjectUpdateTransform();\n    }\n\n    /**\n     * The tint applied to the container. This is a hex value.\n     * A value of 0xFFFFFF will remove any tint effect.\n     * IMPORTANT: This is a WebGL only feature and will be ignored by the canvas renderer.\n     * @default 0xFFFFFF\n     */\n    get tint(): number\n    {\n        return this._tint;\n    }\n\n    set tint(value: number)\n    {\n        this._tint = value;\n        hex2rgb(value, this.tintRgb);\n    }\n\n    /**\n     * Renders the container using the WebGL renderer.\n     * @param renderer - The WebGL renderer.\n     */\n    public render(renderer: Renderer): void\n    {\n        if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable)\n        {\n            return;\n        }\n\n        if (!this.baseTexture)\n        {\n            this.baseTexture = this.children[0]._texture.baseTexture;\n            if (!this.baseTexture.valid)\n            {\n                this.baseTexture.once('update', () => this.onChildrenChange(0));\n            }\n        }\n\n        renderer.batch.setObjectRenderer(renderer.plugins.particle);\n        renderer.plugins.particle.render(this);\n    }\n\n    /**\n     * Set the flag that static data should be updated to true\n     * @param smallestChildIndex - The smallest child index.\n     */\n    protected onChildrenChange(smallestChildIndex: number): void\n    {\n        const bufferIndex = Math.floor(smallestChildIndex / this._batchSize);\n\n        while (this._bufferUpdateIDs.length < bufferIndex)\n        {\n            this._bufferUpdateIDs.push(0);\n        }\n        this._bufferUpdateIDs[bufferIndex] = ++this._updateID;\n    }\n\n    public dispose(): void\n    {\n        if (this._buffers)\n        {\n            for (let i = 0; i < this._buffers.length; ++i)\n            {\n                this._buffers[i].destroy();\n            }\n\n            this._buffers = null;\n        }\n    }\n\n    /**\n     * Destroys the container\n     * @param options - Options parameter. A boolean will act as if all options\n     *  have been set to that value\n     * @param {boolean} [options.children=false] - if set to true, all the children will have their\n     *  destroy method called as well. 'options' will be passed on to those calls.\n     * @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true\n     *  Should it destroy the texture of the child sprite\n     * @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true\n     *  Should it destroy the base texture of the child sprite\n     */\n    public destroy(options?: IDestroyOptions | boolean): void\n    {\n        super.destroy(options);\n\n        this.dispose();\n\n        this._properties = null;\n        this._buffers = null;\n        this._bufferUpdateIDs = null;\n    }\n}\n","/**\n * Constants that define the type of gradient on text.\n * @static\n * @constant\n * @name TEXT_GRADIENT\n * @memberof PIXI\n * @type {object}\n * @property {number} LINEAR_VERTICAL Vertical gradient\n * @property {number} LINEAR_HORIZONTAL Linear gradient\n */\nexport enum TEXT_GRADIENT\n// eslint-disable-next-line @typescript-eslint/indent\n{\n    LINEAR_VERTICAL = 0,\n    LINEAR_HORIZONTAL = 1\n}\n","import { createIndicesForQuads } from '@pixi/utils';\nimport { Geometry, Buffer } from '@pixi/core';\nimport { TYPES } from '@pixi/constants';\n\nimport type { Sprite } from '@pixi/sprite';\nimport type { IParticleRendererProperty } from './ParticleRenderer';\n\n/*\n * @author Mat Groves\n *\n * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/\n * for creating the original PixiJS version!\n * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that\n * they now share 4 bytes on the vertex buffer\n *\n * Heavily inspired by LibGDX's ParticleBuffer:\n * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleBuffer.java\n */\n\n/**\n * The particle buffer manages the static and dynamic buffers for a particle container.\n * @private\n * @memberof PIXI\n */\nexport class ParticleBuffer\n{\n    public geometry: Geometry;\n    public staticStride: number;\n    public staticBuffer: Buffer;\n    public staticData: Float32Array;\n    public staticDataUint32: Uint32Array;\n    public dynamicStride: number;\n    public dynamicBuffer: Buffer;\n    public dynamicData: Float32Array;\n    public dynamicDataUint32: Uint32Array;\n    public _updateID: number;\n\n    /** Holds the indices of the geometry (quads) to draw. */\n    indexBuffer: Buffer;\n\n    /** The number of particles the buffer can hold. */\n    private size: number;\n\n    /** A list of the properties that are dynamic. */\n    private dynamicProperties: IParticleRendererProperty[];\n\n    /** A list of the properties that are static. */\n    private staticProperties: IParticleRendererProperty[];\n\n    /**\n     * @param {object} properties - The properties to upload.\n     * @param {boolean[]} dynamicPropertyFlags - Flags for which properties are dynamic.\n     * @param {number} size - The size of the batch.\n     */\n    constructor(properties: IParticleRendererProperty[], dynamicPropertyFlags: boolean[], size: number)\n    {\n        this.geometry = new Geometry();\n\n        this.indexBuffer = null;\n\n        this.size = size;\n        this.dynamicProperties = [];\n        this.staticProperties = [];\n\n        for (let i = 0; i < properties.length; ++i)\n        {\n            let property = properties[i];\n\n            // Make copy of properties object so that when we edit the offset it doesn't\n            // change all other instances of the object literal\n            property = {\n                attributeName: property.attributeName,\n                size: property.size,\n                uploadFunction: property.uploadFunction,\n                type: property.type || TYPES.FLOAT,\n                offset: property.offset,\n            };\n\n            if (dynamicPropertyFlags[i])\n            {\n                this.dynamicProperties.push(property);\n            }\n            else\n            {\n                this.staticProperties.push(property);\n            }\n        }\n\n        this.staticStride = 0;\n        this.staticBuffer = null;\n        this.staticData = null;\n        this.staticDataUint32 = null;\n\n        this.dynamicStride = 0;\n        this.dynamicBuffer = null;\n        this.dynamicData = null;\n        this.dynamicDataUint32 = null;\n\n        this._updateID = 0;\n\n        this.initBuffers();\n    }\n\n    /** Sets up the renderer context and necessary buffers. */\n    private initBuffers(): void\n    {\n        const geometry = this.geometry;\n\n        let dynamicOffset = 0;\n\n        this.indexBuffer = new Buffer(createIndicesForQuads(this.size), true, true);\n        geometry.addIndex(this.indexBuffer);\n\n        this.dynamicStride = 0;\n\n        for (let i = 0; i < this.dynamicProperties.length; ++i)\n        {\n            const property = this.dynamicProperties[i];\n\n            property.offset = dynamicOffset;\n            dynamicOffset += property.size;\n            this.dynamicStride += property.size;\n        }\n\n        const dynBuffer = new ArrayBuffer(this.size * this.dynamicStride * 4 * 4);\n\n        this.dynamicData = new Float32Array(dynBuffer);\n        this.dynamicDataUint32 = new Uint32Array(dynBuffer);\n        this.dynamicBuffer = new Buffer(this.dynamicData, false, false);\n\n        // static //\n        let staticOffset = 0;\n\n        this.staticStride = 0;\n\n        for (let i = 0; i < this.staticProperties.length; ++i)\n        {\n            const property = this.staticProperties[i];\n\n            property.offset = staticOffset;\n            staticOffset += property.size;\n            this.staticStride += property.size;\n        }\n\n        const statBuffer = new ArrayBuffer(this.size * this.staticStride * 4 * 4);\n\n        this.staticData = new Float32Array(statBuffer);\n        this.staticDataUint32 = new Uint32Array(statBuffer);\n        this.staticBuffer = new Buffer(this.staticData, true, false);\n\n        for (let i = 0; i < this.dynamicProperties.length; ++i)\n        {\n            const property = this.dynamicProperties[i];\n\n            geometry.addAttribute(\n                property.attributeName,\n                this.dynamicBuffer,\n                0,\n                property.type === TYPES.UNSIGNED_BYTE,\n                property.type,\n                this.dynamicStride * 4,\n                property.offset * 4\n            );\n        }\n\n        for (let i = 0; i < this.staticProperties.length; ++i)\n        {\n            const property = this.staticProperties[i];\n\n            geometry.addAttribute(\n                property.attributeName,\n                this.staticBuffer,\n                0,\n                property.type === TYPES.UNSIGNED_BYTE,\n                property.type,\n                this.staticStride * 4,\n                property.offset * 4\n            );\n        }\n    }\n\n    /**\n     * Uploads the dynamic properties.\n     * @param children - The children to upload.\n     * @param startIndex - The index to start at.\n     * @param amount - The number to upload.\n     */\n    uploadDynamic(children: Sprite[], startIndex: number, amount: number): void\n    {\n        for (let i = 0; i < this.dynamicProperties.length; i++)\n        {\n            const property = this.dynamicProperties[i];\n\n            property.uploadFunction(children, startIndex, amount,\n                property.type === TYPES.UNSIGNED_BYTE ? this.dynamicDataUint32 : this.dynamicData,\n                this.dynamicStride, property.offset);\n        }\n\n        this.dynamicBuffer._updateID++;\n    }\n\n    /**\n     * Uploads the static properties.\n     * @param children - The children to upload.\n     * @param startIndex - The index to start at.\n     * @param amount - The number to upload.\n     */\n    uploadStatic(children: Sprite[], startIndex: number, amount: number): void\n    {\n        for (let i = 0; i < this.staticProperties.length; i++)\n        {\n            const property = this.staticProperties[i];\n\n            property.uploadFunction(children, startIndex, amount,\n                property.type === TYPES.UNSIGNED_BYTE ? this.staticDataUint32 : this.staticData,\n                this.staticStride, property.offset);\n        }\n\n        this.staticBuffer._updateID++;\n    }\n\n    /** Destroys the ParticleBuffer. */\n    destroy(): void\n    {\n        this.indexBuffer = null;\n\n        this.dynamicProperties = null;\n        this.dynamicBuffer = null;\n        this.dynamicData = null;\n        this.dynamicDataUint32 = null;\n\n        this.staticProperties = null;\n        this.staticBuffer = null;\n        this.staticData = null;\n        this.staticDataUint32 = null;\n        // all buffers are destroyed inside geometry\n        this.geometry.destroy();\n    }\n}\n","import { TYPES } from '@pixi/constants';\nimport { ExtensionType, ObjectRenderer, Shader, State } from '@pixi/core';\nimport { Matrix } from '@pixi/math';\nimport { correctBlendMode, premultiplyRgba, premultiplyTint } from '@pixi/utils';\nimport { ParticleBuffer } from './ParticleBuffer';\nimport fragment from './particles.frag';\nimport vertex from './particles.vert';\n\nimport type { ParticleContainer } from './ParticleContainer';\nimport type { Renderer, ExtensionMetadata } from '@pixi/core';\nimport type { Sprite } from '@pixi/sprite';\n\nexport interface IParticleRendererProperty\n{\n    attributeName: string;\n    size: number;\n    type?: TYPES;\n    uploadFunction: (...params: any[]) => any;\n    offset: number;\n}\n\n/*\n * @author Mat Groves\n *\n * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/\n * for creating the original PixiJS version!\n * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now\n * share 4 bytes on the vertex buffer\n *\n * Heavily inspired by LibGDX's ParticleRenderer:\n * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/ParticleRenderer.java\n */\n\n/**\n * Renderer for Particles that is designer for speed over feature set.\n * @memberof PIXI\n */\nexport class ParticleRenderer extends ObjectRenderer\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'particle',\n        type: ExtensionType.RendererPlugin,\n    };\n\n    /** The WebGL state in which this renderer will work. */\n    public readonly state: State;\n\n    /** The default shader that is used if a sprite doesn't have a more specific one. */\n    public shader: Shader;\n    public tempMatrix: Matrix;\n    public properties: IParticleRendererProperty[];\n\n    /**\n     * @param renderer - The renderer this sprite batch works for.\n     */\n    constructor(renderer: Renderer)\n    {\n        super(renderer);\n\n        // 65535 is max vertex index in the index buffer (see ParticleRenderer)\n        // so max number of particles is 65536 / 4 = 16384\n        // and max number of element in the index buffer is 16384 * 6 = 98304\n        // Creating a full index buffer, overhead is 98304 * 2 = 196Ko\n        // let numIndices = 98304;\n\n        this.shader = null;\n\n        this.properties = null;\n\n        this.tempMatrix = new Matrix();\n\n        this.properties = [\n            // verticesData\n            {\n                attributeName: 'aVertexPosition',\n                size: 2,\n                uploadFunction: this.uploadVertices,\n                offset: 0,\n            },\n            // positionData\n            {\n                attributeName: 'aPositionCoord',\n                size: 2,\n                uploadFunction: this.uploadPosition,\n                offset: 0,\n            },\n            // rotationData\n            {\n                attributeName: 'aRotation',\n                size: 1,\n                uploadFunction: this.uploadRotation,\n                offset: 0,\n            },\n            // uvsData\n            {\n                attributeName: 'aTextureCoord',\n                size: 2,\n                uploadFunction: this.uploadUvs,\n                offset: 0,\n            },\n            // tintData\n            {\n                attributeName: 'aColor',\n                size: 1,\n                type: TYPES.UNSIGNED_BYTE,\n                uploadFunction: this.uploadTint,\n                offset: 0,\n            },\n        ];\n\n        this.shader = Shader.from(vertex, fragment, {});\n        this.state = State.for2d();\n    }\n\n    /**\n     * Renders the particle container object.\n     * @param container - The container to render using this ParticleRenderer.\n     */\n    public render(container: ParticleContainer): void\n    {\n        const children = container.children;\n        const maxSize = container._maxSize;\n        const batchSize = container._batchSize;\n        const renderer = this.renderer;\n        let totalChildren = children.length;\n\n        if (totalChildren === 0)\n        {\n            return;\n        }\n        else if (totalChildren > maxSize && !container.autoResize)\n        {\n            totalChildren = maxSize;\n        }\n\n        let buffers = container._buffers;\n\n        if (!buffers)\n        {\n            buffers = container._buffers = this.generateBuffers(container);\n        }\n\n        const baseTexture = children[0]._texture.baseTexture;\n        const premultiplied = baseTexture.alphaMode > 0;\n\n        // if the uvs have not updated then no point rendering just yet!\n        this.state.blendMode = correctBlendMode(container.blendMode, premultiplied);\n        renderer.state.set(this.state);\n\n        const gl = renderer.gl;\n\n        const m = container.worldTransform.copyTo(this.tempMatrix);\n\n        m.prepend(renderer.globalUniforms.uniforms.projectionMatrix);\n\n        this.shader.uniforms.translationMatrix = m.toArray(true);\n\n        this.shader.uniforms.uColor = premultiplyRgba(container.tintRgb,\n            container.worldAlpha, this.shader.uniforms.uColor, premultiplied);\n\n        this.shader.uniforms.uSampler = baseTexture;\n\n        this.renderer.shader.bind(this.shader);\n\n        let updateStatic = false;\n\n        // now lets upload and render the buffers..\n        for (let i = 0, j = 0; i < totalChildren; i += batchSize, j += 1)\n        {\n            let amount = (totalChildren - i);\n\n            if (amount > batchSize)\n            {\n                amount = batchSize;\n            }\n\n            if (j >= buffers.length)\n            {\n                buffers.push(this._generateOneMoreBuffer(container));\n            }\n\n            const buffer = buffers[j];\n\n            // we always upload the dynamic\n            buffer.uploadDynamic(children, i, amount);\n\n            const bid = container._bufferUpdateIDs[j] || 0;\n\n            updateStatic = updateStatic || (buffer._updateID < bid);\n            // we only upload the static content when we have to!\n            if (updateStatic)\n            {\n                buffer._updateID = container._updateID;\n                buffer.uploadStatic(children, i, amount);\n            }\n\n            // bind the buffer\n            renderer.geometry.bind(buffer.geometry);\n            gl.drawElements(gl.TRIANGLES, amount * 6, gl.UNSIGNED_SHORT, 0);\n        }\n    }\n\n    /**\n     * Creates one particle buffer for each child in the container we want to render and updates internal properties.\n     * @param container - The container to render using this ParticleRenderer\n     * @returns - The buffers\n     */\n    private generateBuffers(container: ParticleContainer): ParticleBuffer[]\n    {\n        const buffers = [];\n        const size = container._maxSize;\n        const batchSize = container._batchSize;\n        const dynamicPropertyFlags = container._properties;\n\n        for (let i = 0; i < size; i += batchSize)\n        {\n            buffers.push(new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize));\n        }\n\n        return buffers;\n    }\n\n    /**\n     * Creates one more particle buffer, because container has autoResize feature.\n     * @param container - The container to render using this ParticleRenderer\n     * @returns - The generated buffer\n     */\n    private _generateOneMoreBuffer(container: ParticleContainer): ParticleBuffer\n    {\n        const batchSize = container._batchSize;\n        const dynamicPropertyFlags = container._properties;\n\n        return new ParticleBuffer(this.properties, dynamicPropertyFlags, batchSize);\n    }\n\n    /**\n     * Uploads the vertices.\n     * @param children - the array of sprites to render\n     * @param startIndex - the index to start from in the children array\n     * @param amount - the amount of children that will have their vertices uploaded\n     * @param array - The vertices to upload.\n     * @param stride - Stride to use for iteration.\n     * @param offset - Offset to start at.\n     */\n    public uploadVertices(\n        children: Sprite[], startIndex: number, amount: number,\n        array: number[], stride: number, offset: number\n    ): void\n    {\n        let w0 = 0;\n        let w1 = 0;\n        let h0 = 0;\n        let h1 = 0;\n\n        for (let i = 0; i < amount; ++i)\n        {\n            const sprite = children[startIndex + i];\n            const texture = sprite._texture;\n            const sx = sprite.scale.x;\n            const sy = sprite.scale.y;\n            const trim = texture.trim;\n            const orig = texture.orig;\n\n            if (trim)\n            {\n                // if the sprite is trimmed and is not a tilingsprite then we need to add the\n                // extra space before transforming the sprite coords..\n                w1 = trim.x - (sprite.anchor.x * orig.width);\n                w0 = w1 + trim.width;\n\n                h1 = trim.y - (sprite.anchor.y * orig.height);\n                h0 = h1 + trim.height;\n            }\n            else\n            {\n                w0 = (orig.width) * (1 - sprite.anchor.x);\n                w1 = (orig.width) * -sprite.anchor.x;\n\n                h0 = orig.height * (1 - sprite.anchor.y);\n                h1 = orig.height * -sprite.anchor.y;\n            }\n\n            array[offset] = w1 * sx;\n            array[offset + 1] = h1 * sy;\n\n            array[offset + stride] = w0 * sx;\n            array[offset + stride + 1] = h1 * sy;\n\n            array[offset + (stride * 2)] = w0 * sx;\n            array[offset + (stride * 2) + 1] = h0 * sy;\n\n            array[offset + (stride * 3)] = w1 * sx;\n            array[offset + (stride * 3) + 1] = h0 * sy;\n\n            offset += stride * 4;\n        }\n    }\n\n    /**\n     * Uploads the position.\n     * @param children - the array of sprites to render\n     * @param startIndex - the index to start from in the children array\n     * @param amount - the amount of children that will have their positions uploaded\n     * @param array - The vertices to upload.\n     * @param stride - Stride to use for iteration.\n     * @param offset - Offset to start at.\n     */\n    public uploadPosition(\n        children: Sprite[], startIndex: number, amount: number,\n        array: number[], stride: number, offset: number\n    ): void\n    {\n        for (let i = 0; i < amount; i++)\n        {\n            const spritePosition = children[startIndex + i].position;\n\n            array[offset] = spritePosition.x;\n            array[offset + 1] = spritePosition.y;\n\n            array[offset + stride] = spritePosition.x;\n            array[offset + stride + 1] = spritePosition.y;\n\n            array[offset + (stride * 2)] = spritePosition.x;\n            array[offset + (stride * 2) + 1] = spritePosition.y;\n\n            array[offset + (stride * 3)] = spritePosition.x;\n            array[offset + (stride * 3) + 1] = spritePosition.y;\n\n            offset += stride * 4;\n        }\n    }\n\n    /**\n     * Uploads the rotation.\n     * @param children - the array of sprites to render\n     * @param startIndex - the index to start from in the children array\n     * @param amount - the amount of children that will have their rotation uploaded\n     * @param array - The vertices to upload.\n     * @param stride - Stride to use for iteration.\n     * @param offset - Offset to start at.\n     */\n    public uploadRotation(\n        children: Sprite[], startIndex: number, amount: number,\n        array: number[], stride: number, offset: number\n    ): void\n    {\n        for (let i = 0; i < amount; i++)\n        {\n            const spriteRotation = children[startIndex + i].rotation;\n\n            array[offset] = spriteRotation;\n            array[offset + stride] = spriteRotation;\n            array[offset + (stride * 2)] = spriteRotation;\n            array[offset + (stride * 3)] = spriteRotation;\n\n            offset += stride * 4;\n        }\n    }\n\n    /**\n     * Uploads the UVs.\n     * @param children - the array of sprites to render\n     * @param startIndex - the index to start from in the children array\n     * @param amount - the amount of children that will have their rotation uploaded\n     * @param array - The vertices to upload.\n     * @param stride - Stride to use for iteration.\n     * @param offset - Offset to start at.\n     */\n    public uploadUvs(\n        children: Sprite[], startIndex: number, amount: number,\n        array: number[], stride: number, offset: number\n    ): void\n    {\n        for (let i = 0; i < amount; ++i)\n        {\n            const textureUvs = children[startIndex + i]._texture._uvs;\n\n            if (textureUvs)\n            {\n                array[offset] = textureUvs.x0;\n                array[offset + 1] = textureUvs.y0;\n\n                array[offset + stride] = textureUvs.x1;\n                array[offset + stride + 1] = textureUvs.y1;\n\n                array[offset + (stride * 2)] = textureUvs.x2;\n                array[offset + (stride * 2) + 1] = textureUvs.y2;\n\n                array[offset + (stride * 3)] = textureUvs.x3;\n                array[offset + (stride * 3) + 1] = textureUvs.y3;\n\n                offset += stride * 4;\n            }\n            else\n            {\n                // TODO you know this can be easier!\n                array[offset] = 0;\n                array[offset + 1] = 0;\n\n                array[offset + stride] = 0;\n                array[offset + stride + 1] = 0;\n\n                array[offset + (stride * 2)] = 0;\n                array[offset + (stride * 2) + 1] = 0;\n\n                array[offset + (stride * 3)] = 0;\n                array[offset + (stride * 3) + 1] = 0;\n\n                offset += stride * 4;\n            }\n        }\n    }\n\n    /**\n     * Uploads the tint.\n     * @param children - the array of sprites to render\n     * @param startIndex - the index to start from in the children array\n     * @param amount - the amount of children that will have their rotation uploaded\n     * @param array - The vertices to upload.\n     * @param stride - Stride to use for iteration.\n     * @param offset - Offset to start at.\n     */\n    public uploadTint(\n        children: Sprite[], startIndex: number, amount: number,\n        array: number[], stride: number, offset: number\n    ): void\n    {\n        for (let i = 0; i < amount; ++i)\n        {\n            const sprite = children[startIndex + i];\n            const premultiplied = sprite._texture.baseTexture.alphaMode > 0;\n            const alpha = sprite.alpha;\n\n            // we dont call extra function if alpha is 1.0, that's faster\n            const argb = alpha < 1.0 && premultiplied\n                ? premultiplyTint(sprite._tintRGB, alpha) : sprite._tintRGB + (alpha * 255 << 24);\n\n            array[offset] = argb;\n            array[offset + stride] = argb;\n            array[offset + (stride * 2)] = argb;\n            array[offset + (stride * 3)] = argb;\n\n            offset += stride * 4;\n        }\n    }\n\n    /** Destroys the ParticleRenderer. */\n    public destroy(): void\n    {\n        super.destroy();\n\n        if (this.shader)\n        {\n            this.shader.destroy();\n            this.shader = null;\n        }\n\n        this.tempMatrix = null;\n    }\n}\n","// disabling eslint for now, going to rewrite this in v5\n/* eslint-disable */\n\nimport { TEXT_GRADIENT } from './const';\nimport { hex2string } from '@pixi/utils';\n\nexport type TextStyleAlign = 'left'|'center'|'right'|'justify';\nexport type TextStyleFill = string|string[]|number|number[]|CanvasGradient|CanvasPattern;\nexport type TextStyleFontStyle = 'normal'|'italic'|'oblique';\nexport type TextStyleFontVariant = 'normal'|'small-caps';\nexport type TextStyleFontWeight = 'normal'|'bold'|'bolder'|'lighter'|'100'|'200'|'300'|'400'|'500'|'600'|'700'|'800'|'900';\nexport type TextStyleLineJoin = 'miter'|'round'|'bevel';\nexport type TextStyleTextBaseline = 'alphabetic'|'top'|'hanging'|'middle'|'ideographic'|'bottom';\nexport type TextStyleWhiteSpace = 'normal'|'pre'|'pre-line';\n\nexport interface ITextStyle {\n    align: TextStyleAlign;\n    breakWords: boolean;\n    dropShadow: boolean;\n    dropShadowAlpha: number;\n    dropShadowAngle: number;\n    dropShadowBlur: number;\n    dropShadowColor: string|number;\n    dropShadowDistance: number;\n    fill: TextStyleFill;\n    fillGradientType: TEXT_GRADIENT;\n    fillGradientStops: number[];\n    fontFamily: string | string[];\n    fontSize: number | string;\n    fontStyle: TextStyleFontStyle;\n    fontVariant: TextStyleFontVariant;\n    fontWeight: TextStyleFontWeight;\n    letterSpacing: number;\n    lineHeight: number;\n    lineJoin: TextStyleLineJoin;\n    miterLimit: number;\n    padding: number;\n    stroke: string|number;\n    strokeThickness: number;\n    textBaseline: TextStyleTextBaseline;\n    trim: boolean;\n    whiteSpace: TextStyleWhiteSpace;\n    wordWrap: boolean;\n    wordWrapWidth: number;\n    leading: number;\n}\n\nconst defaultStyle: ITextStyle = {\n    align: 'left',\n    breakWords: false,\n    dropShadow: false,\n    dropShadowAlpha: 1,\n    dropShadowAngle: Math.PI / 6,\n    dropShadowBlur: 0,\n    dropShadowColor: 'black',\n    dropShadowDistance: 5,\n    fill: 'black',\n    fillGradientType: TEXT_GRADIENT.LINEAR_VERTICAL,\n    fillGradientStops: [],\n    fontFamily: 'Arial',\n    fontSize: 26,\n    fontStyle: 'normal',\n    fontVariant: 'normal',\n    fontWeight: 'normal',\n    letterSpacing: 0,\n    lineHeight: 0,\n    lineJoin: 'miter',\n    miterLimit: 10,\n    padding: 0,\n    stroke: 'black',\n    strokeThickness: 0,\n    textBaseline: 'alphabetic',\n    trim: false,\n    whiteSpace: 'pre',\n    wordWrap: false,\n    wordWrapWidth: 100,\n    leading: 0,\n};\n\nconst genericFontFamilies = [\n    'serif',\n    'sans-serif',\n    'monospace',\n    'cursive',\n    'fantasy',\n    'system-ui',\n];\n\n/**\n * A TextStyle Object contains information to decorate a Text objects.\n *\n * An instance can be shared between multiple Text objects; then changing the style will update all text objects using it.\n *\n * A tool can be used to generate a text style [here](https://pixijs.io/pixi-text-style).\n *\n * @memberof PIXI\n */\nexport class TextStyle implements ITextStyle\n{\n    public styleID: number;\n\n    protected _align: TextStyleAlign;\n    protected _breakWords: boolean;\n    protected _dropShadow: boolean;\n    protected _dropShadowAlpha: number;\n    protected _dropShadowAngle: number;\n    protected _dropShadowBlur: number;\n    protected _dropShadowColor: string|number;\n    protected _dropShadowDistance: number;\n    protected _fill: TextStyleFill;\n    protected _fillGradientType: TEXT_GRADIENT;\n    protected _fillGradientStops: number[];\n    protected _fontFamily: string|string[];\n    protected _fontSize: number|string;\n    protected _fontStyle: TextStyleFontStyle;\n    protected _fontVariant: TextStyleFontVariant;\n    protected _fontWeight: TextStyleFontWeight;\n    protected _letterSpacing: number;\n    protected _lineHeight: number;\n    protected _lineJoin: TextStyleLineJoin;\n    protected _miterLimit: number;\n    protected _padding: number;\n    protected _stroke: string|number;\n    protected _strokeThickness: number;\n    protected _textBaseline: TextStyleTextBaseline;\n    protected _trim: boolean;\n    protected _whiteSpace: TextStyleWhiteSpace;\n    protected _wordWrap: boolean;\n    protected _wordWrapWidth: number;\n    protected _leading: number;\n\n    /**\n     * @param {object} [style] - The style parameters\n     * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'),\n     *  does not affect single line text\n     * @param {boolean} [style.breakWords=false] - Indicates if lines can be wrapped within words, it\n     *  needs wordWrap to be set to true\n     * @param {boolean} [style.dropShadow=false] - Set a drop shadow for the text\n     * @param {number} [style.dropShadowAlpha=1] - Set alpha for the drop shadow\n     * @param {number} [style.dropShadowAngle=Math.PI/6] - Set a angle of the drop shadow\n     * @param {number} [style.dropShadowBlur=0] - Set a shadow blur radius\n     * @param {string|number} [style.dropShadowColor='black'] - A fill style to be used on the dropshadow e.g 'red', '#00FF00'\n     * @param {number} [style.dropShadowDistance=5] - Set a distance of the drop shadow\n     * @param {string|string[]|number|number[]|CanvasGradient|CanvasPattern} [style.fill='black'] - A canvas\n     *  fillstyle that will be used on the text e.g 'red', '#00FF00'. Can be an array to create a gradient\n     *  eg ['#000000','#FFFFFF']\n     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}\n     * @param {number} [style.fillGradientType=PIXI.TEXT_GRADIENT.LINEAR_VERTICAL] - If fill is an array of colours\n     *  to create a gradient, this can change the type/direction of the gradient. See {@link PIXI.TEXT_GRADIENT}\n     * @param {number[]} [style.fillGradientStops] - If fill is an array of colours to create a gradient, this array can set\n     * the stop points (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.\n     * @param {string|string[]} [style.fontFamily='Arial'] - The font family\n     * @param {number|string} [style.fontSize=26] - The font size (as a number it converts to px, but as a string,\n     *  equivalents are '26px','20pt','160%' or '1.6em')\n     * @param {string} [style.fontStyle='normal'] - The font style ('normal', 'italic' or 'oblique')\n     * @param {string} [style.fontVariant='normal'] - The font variant ('normal' or 'small-caps')\n     * @param {string} [style.fontWeight='normal'] - The font weight ('normal', 'bold', 'bolder', 'lighter' and '100',\n     *  '200', '300', '400', '500', '600', '700', '800' or '900')\n     * @param {number} [style.leading=0] - The space between lines\n     * @param {number} [style.letterSpacing=0] - The amount of spacing between letters, default is 0\n     * @param {number} [style.lineHeight] - The line height, a number that represents the vertical space that a letter uses\n     * @param {string} [style.lineJoin='miter'] - The lineJoin property sets the type of corner created, it can resolve\n     *      spiked text issues. Possible values \"miter\" (creates a sharp corner), \"round\" (creates a round corner) or \"bevel\"\n     *      (creates a squared corner).\n     * @param {number} [style.miterLimit=10] - The miter limit to use when using the 'miter' lineJoin mode. This can reduce\n     *      or increase the spikiness of rendered text.\n     * @param {number} [style.padding=0] - Occasionally some fonts are cropped. Adding some padding will prevent this from\n     *     happening by adding padding to all sides of the text.\n     * @param {string|number} [style.stroke='black'] - A canvas fillstyle that will be used on the text stroke\n     *  e.g 'blue', '#FCFF00'\n     * @param {number} [style.strokeThickness=0] - A number that represents the thickness of the stroke.\n     *  Default is 0 (no stroke)\n     * @param {boolean} [style.trim=false] - Trim transparent borders\n     * @param {string} [style.textBaseline='alphabetic'] - The baseline of the text that is rendered.\n     * @param {string} [style.whiteSpace='pre'] - Determines whether newlines & spaces are collapsed or preserved \"normal\"\n     *      (collapse, collapse), \"pre\" (preserve, preserve) | \"pre-line\" (preserve, collapse). It needs wordWrap to be set to true\n     * @param {boolean} [style.wordWrap=false] - Indicates if word wrap should be used\n     * @param {number} [style.wordWrapWidth=100] - The width at which text will wrap, it needs wordWrap to be set to true\n     */\n    constructor(style?: Partial<ITextStyle>)\n    {\n        this.styleID = 0;\n\n        this.reset();\n\n        deepCopyProperties(this, style, style);\n    }\n\n    /**\n     * Creates a new TextStyle object with the same values as this one.\n     * Note that the only the properties of the object are cloned.\n     *\n     * @return New cloned TextStyle object\n     */\n    public clone(): TextStyle\n    {\n        const clonedProperties: Partial<ITextStyle> = {};\n\n        deepCopyProperties(clonedProperties, this, defaultStyle);\n\n        return new TextStyle(clonedProperties);\n    }\n\n    /** Resets all properties to the defaults specified in TextStyle.prototype._default */\n    public reset(): void\n    {\n        deepCopyProperties(this, defaultStyle, defaultStyle);\n    }\n\n    /**\n     * Alignment for multiline text ('left', 'center' or 'right'), does not affect single line text\n     *\n     * @member {string}\n     */\n    get align(): TextStyleAlign\n    {\n        return this._align;\n    }\n    set align(align: TextStyleAlign)\n    {\n        if (this._align !== align)\n        {\n            this._align = align;\n            this.styleID++;\n        }\n    }\n\n    /** Indicates if lines can be wrapped within words, it needs wordWrap to be set to true. */\n    get breakWords(): boolean\n    {\n        return this._breakWords;\n    }\n    set breakWords(breakWords: boolean)\n    {\n        if (this._breakWords !== breakWords)\n        {\n            this._breakWords = breakWords;\n            this.styleID++;\n        }\n    }\n\n    /** Set a drop shadow for the text. */\n    get dropShadow(): boolean\n    {\n        return this._dropShadow;\n    }\n    set dropShadow(dropShadow: boolean)\n    {\n        if (this._dropShadow !== dropShadow)\n        {\n            this._dropShadow = dropShadow;\n            this.styleID++;\n        }\n    }\n\n    /** Set alpha for the drop shadow. */\n    get dropShadowAlpha(): number\n    {\n        return this._dropShadowAlpha;\n    }\n    set dropShadowAlpha(dropShadowAlpha: number)\n    {\n        if (this._dropShadowAlpha !== dropShadowAlpha)\n        {\n            this._dropShadowAlpha = dropShadowAlpha;\n            this.styleID++;\n        }\n    }\n\n    /** Set a angle of the drop shadow. */\n    get dropShadowAngle(): number\n    {\n        return this._dropShadowAngle;\n    }\n    set dropShadowAngle(dropShadowAngle: number)\n    {\n        if (this._dropShadowAngle !== dropShadowAngle)\n        {\n            this._dropShadowAngle = dropShadowAngle;\n            this.styleID++;\n        }\n    }\n\n    /** Set a shadow blur radius. */\n    get dropShadowBlur(): number\n    {\n        return this._dropShadowBlur;\n    }\n    set dropShadowBlur(dropShadowBlur: number)\n    {\n        if (this._dropShadowBlur !== dropShadowBlur)\n        {\n            this._dropShadowBlur = dropShadowBlur;\n            this.styleID++;\n        }\n    }\n\n    /** A fill style to be used on the dropshadow e.g 'red', '#00FF00'. */\n    get dropShadowColor(): number | string\n    {\n        return this._dropShadowColor;\n    }\n    set dropShadowColor(dropShadowColor: number | string)\n    {\n        const outputColor = getColor(dropShadowColor);\n        if (this._dropShadowColor !== outputColor)\n        {\n            this._dropShadowColor = outputColor;\n            this.styleID++;\n        }\n    }\n\n    /** Set a distance of the drop shadow. */\n    get dropShadowDistance(): number\n    {\n        return this._dropShadowDistance;\n    }\n    set dropShadowDistance(dropShadowDistance: number)\n    {\n        if (this._dropShadowDistance !== dropShadowDistance)\n        {\n            this._dropShadowDistance = dropShadowDistance;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * A canvas fillstyle that will be used on the text e.g 'red', '#00FF00'.\n     *\n     * Can be an array to create a gradient eg ['#000000','#FFFFFF']\n     * {@link https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillStyle|MDN}\n     *\n     * @member {string|string[]|number|number[]|CanvasGradient|CanvasPattern}\n     */\n    get fill(): TextStyleFill\n    {\n        return this._fill;\n    }\n    set fill(fill: TextStyleFill)\n    {\n        // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as\n        //       the setter converts to string. See this thread for more details:\n        //       https://github.com/microsoft/TypeScript/issues/2521\n        // TODO: Not sure if getColor works properly with CanvasGradient and/or CanvasPattern, can't pass in\n        //       without casting here.\n        const outputColor = getColor(fill as any);\n        if (this._fill !== outputColor)\n        {\n            this._fill = outputColor;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * If fill is an array of colours to create a gradient, this can change the type/direction of the gradient.\n     *\n     * @see PIXI.TEXT_GRADIENT\n     */\n    get fillGradientType(): TEXT_GRADIENT\n    {\n        return this._fillGradientType;\n    }\n    set fillGradientType(fillGradientType: TEXT_GRADIENT)\n    {\n        if (this._fillGradientType !== fillGradientType)\n        {\n            this._fillGradientType = fillGradientType;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * If fill is an array of colours to create a gradient, this array can set the stop points\n     * (numbers between 0 and 1) for the color, overriding the default behaviour of evenly spacing them.\n     */\n    get fillGradientStops(): number[]\n    {\n        return this._fillGradientStops;\n    }\n    set fillGradientStops(fillGradientStops: number[])\n    {\n        if (!areArraysEqual(this._fillGradientStops,fillGradientStops))\n        {\n            this._fillGradientStops = fillGradientStops;\n            this.styleID++;\n        }\n    }\n\n    /** The font family. */\n    get fontFamily(): string | string[]\n    {\n        return this._fontFamily;\n    }\n    set fontFamily(fontFamily: string | string[])\n    {\n        if (this.fontFamily !== fontFamily)\n        {\n            this._fontFamily = fontFamily;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The font size\n     * (as a number it converts to px, but as a string, equivalents are '26px','20pt','160%' or '1.6em')\n     */\n    get fontSize(): number | string\n    {\n        return this._fontSize;\n    }\n    set fontSize(fontSize: number | string)\n    {\n        if (this._fontSize !== fontSize)\n        {\n            this._fontSize = fontSize;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The font style\n     * ('normal', 'italic' or 'oblique')\n     *\n     * @member {string}\n     */\n    get fontStyle(): TextStyleFontStyle\n    {\n        return this._fontStyle;\n    }\n    set fontStyle(fontStyle: TextStyleFontStyle)\n    {\n        if (this._fontStyle !== fontStyle)\n        {\n            this._fontStyle = fontStyle;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The font variant\n     * ('normal' or 'small-caps')\n     *\n     * @member {string}\n     */\n    get fontVariant(): TextStyleFontVariant\n    {\n        return this._fontVariant;\n    }\n    set fontVariant(fontVariant: TextStyleFontVariant)\n    {\n        if (this._fontVariant !== fontVariant)\n        {\n            this._fontVariant = fontVariant;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The font weight\n     * ('normal', 'bold', 'bolder', 'lighter' and '100', '200', '300', '400', '500', '600', '700', 800' or '900')\n     *\n     * @member {string}\n     */\n    get fontWeight(): TextStyleFontWeight\n    {\n        return this._fontWeight;\n    }\n    set fontWeight(fontWeight: TextStyleFontWeight)\n    {\n        if (this._fontWeight !== fontWeight)\n        {\n            this._fontWeight = fontWeight;\n            this.styleID++;\n        }\n    }\n\n    /** The amount of spacing between letters, default is 0. */\n    get letterSpacing(): number\n    {\n        return this._letterSpacing;\n    }\n    set letterSpacing(letterSpacing: number)\n    {\n        if (this._letterSpacing !== letterSpacing)\n        {\n            this._letterSpacing = letterSpacing;\n            this.styleID++;\n        }\n    }\n\n    /** The line height, a number that represents the vertical space that a letter uses. */\n    get lineHeight(): number\n    {\n        return this._lineHeight;\n    }\n    set lineHeight(lineHeight: number)\n    {\n        if (this._lineHeight !== lineHeight)\n        {\n            this._lineHeight = lineHeight;\n            this.styleID++;\n        }\n    }\n\n    /** The space between lines. */\n    get leading(): number\n    {\n        return this._leading;\n    }\n    set leading(leading: number)\n    {\n        if (this._leading !== leading)\n        {\n            this._leading = leading;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The lineJoin property sets the type of corner created, it can resolve spiked text issues.\n     * Default is 'miter' (creates a sharp corner).\n     *\n     * @member {string}\n     */\n    get lineJoin(): TextStyleLineJoin\n    {\n        return this._lineJoin;\n    }\n    set lineJoin(lineJoin: TextStyleLineJoin)\n    {\n        if (this._lineJoin !== lineJoin)\n        {\n            this._lineJoin = lineJoin;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The miter limit to use when using the 'miter' lineJoin mode.\n     *\n     * This can reduce or increase the spikiness of rendered text.\n     */\n    get miterLimit(): number\n    {\n        return this._miterLimit;\n    }\n    set miterLimit(miterLimit: number)\n    {\n        if (this._miterLimit !== miterLimit)\n        {\n            this._miterLimit = miterLimit;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * Occasionally some fonts are cropped. Adding some padding will prevent this from happening\n     * by adding padding to all sides of the text.\n     */\n    get padding(): number\n    {\n        return this._padding;\n    }\n    set padding(padding: number)\n    {\n        if (this._padding !== padding)\n        {\n            this._padding = padding;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * A canvas fillstyle that will be used on the text stroke\n     * e.g 'blue', '#FCFF00'\n     */\n    get stroke(): string | number\n    {\n        return this._stroke;\n    }\n    set stroke(stroke: string | number)\n    {\n        // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as\n        //       the setter converts to string. See this thread for more details:\n        //       https://github.com/microsoft/TypeScript/issues/2521\n        const outputColor = getColor(stroke);\n        if (this._stroke !== outputColor)\n        {\n            this._stroke = outputColor;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * A number that represents the thickness of the stroke.\n     *\n     * @default 0\n     */\n    get strokeThickness(): number\n    {\n        return this._strokeThickness;\n    }\n    set strokeThickness(strokeThickness: number)\n    {\n        if (this._strokeThickness !== strokeThickness)\n        {\n            this._strokeThickness = strokeThickness;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * The baseline of the text that is rendered.\n     *\n     * @member {string}\n     */\n    get textBaseline(): TextStyleTextBaseline\n    {\n        return this._textBaseline;\n    }\n    set textBaseline(textBaseline: TextStyleTextBaseline)\n    {\n        if (this._textBaseline !== textBaseline)\n        {\n            this._textBaseline = textBaseline;\n            this.styleID++;\n        }\n    }\n\n    /** Trim transparent borders. */\n    get trim(): boolean\n    {\n        return this._trim;\n    }\n    set trim(trim: boolean)\n    {\n        if (this._trim !== trim)\n        {\n            this._trim = trim;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * How newlines and spaces should be handled.\n     * Default is 'pre' (preserve, preserve).\n     *\n     *  value       | New lines     |   Spaces\n     *  ---         | ---           |   ---\n     * 'normal'     | Collapse      |   Collapse\n     * 'pre'        | Preserve      |   Preserve\n     * 'pre-line'   | Preserve      |   Collapse\n     *\n     * @member {string}\n     */\n    get whiteSpace(): TextStyleWhiteSpace\n    {\n        return this._whiteSpace;\n    }\n    set whiteSpace(whiteSpace: TextStyleWhiteSpace)\n    {\n        if (this._whiteSpace !== whiteSpace)\n        {\n            this._whiteSpace = whiteSpace;\n            this.styleID++;\n        }\n    }\n\n    /** Indicates if word wrap should be used. */\n    get wordWrap(): boolean\n    {\n        return this._wordWrap;\n    }\n    set wordWrap(wordWrap: boolean)\n    {\n        if (this._wordWrap !== wordWrap)\n        {\n            this._wordWrap = wordWrap;\n            this.styleID++;\n        }\n    }\n\n    /** The width at which text will wrap, it needs wordWrap to be set to true. */\n    get wordWrapWidth(): number\n    {\n        return this._wordWrapWidth;\n    }\n    set wordWrapWidth(wordWrapWidth: number)\n    {\n        if (this._wordWrapWidth !== wordWrapWidth)\n        {\n            this._wordWrapWidth = wordWrapWidth;\n            this.styleID++;\n        }\n    }\n\n    /**\n     * Generates a font style string to use for `TextMetrics.measureFont()`.\n     *\n     * @return Font style string, for passing to `TextMetrics.measureFont()`\n     */\n    public toFontString(): string\n    {\n        // build canvas api font setting from individual components. Convert a numeric this.fontSize to px\n        const fontSizeString = (typeof this.fontSize === 'number') ? `${this.fontSize}px` : this.fontSize;\n\n        // Clean-up fontFamily property by quoting each font name\n        // this will support font names with spaces\n        let fontFamilies: string|string[] = this.fontFamily;\n\n        if (!Array.isArray(this.fontFamily))\n        {\n            fontFamilies = this.fontFamily.split(',');\n        }\n\n        for (let i = fontFamilies.length - 1; i >= 0; i--)\n        {\n            // Trim any extra white-space\n            let fontFamily = fontFamilies[i].trim();\n\n            // Check if font already contains strings\n            if (!(/([\\\"\\'])[^\\'\\\"]+\\1/).test(fontFamily) && genericFontFamilies.indexOf(fontFamily) < 0)\n            {\n                fontFamily = `\"${fontFamily}\"`;\n            }\n            (fontFamilies as string[])[i] = fontFamily;\n        }\n\n        return `${this.fontStyle} ${this.fontVariant} ${this.fontWeight} ${fontSizeString} ${(fontFamilies as string[]).join(',')}`;\n    }\n}\n\n/**\n * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.\n * @private\n * @param color\n * @return The color as a string.\n */\nfunction getSingleColor(color: string|number): string\n{\n    if (typeof color === 'number')\n    {\n        return hex2string(color);\n    }\n    else if (typeof color === 'string')\n    {\n        if ( color.indexOf('0x') === 0 )\n        {\n            color = color.replace('0x', '#');\n        }\n    }\n\n    return color;\n}\n\n/**\n * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.\n * This version can also convert array of colors\n * @private\n * @param color\n * @return The color as a string.\n */\nfunction getColor(color: (string|number)[]): string[];\nfunction getColor(color: string|number): string;\nfunction getColor(color: string|number|(string|number)[]): string|string[]\n{\n    if (!Array.isArray(color))\n    {\n        return getSingleColor(color);\n    }\n    else\n    {\n        for (let i = 0; i < color.length; ++i)\n        {\n            color[i] = getSingleColor(color[i]);\n        }\n\n        return color as string[];\n    }\n}\n\n/**\n * Utility function to convert hexadecimal colors to strings, and simply return the color if it's a string.\n * This version can also convert array of colors\n * @private\n * @param array1 - First array to compare\n * @param array2 - Second array to compare\n * @return Do the arrays contain the same values in the same order\n */\nfunction areArraysEqual<T>(array1: T[], array2: T[]): boolean\n{\n    if (!Array.isArray(array1) || !Array.isArray(array2))\n    {\n        return false;\n    }\n\n    if (array1.length !== array2.length)\n    {\n        return false;\n    }\n\n    for (let i = 0; i < array1.length; ++i)\n    {\n        if (array1[i] !== array2[i])\n        {\n            return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Utility function to ensure that object properties are copied by value, and not by reference\n * @private\n * @param target - Target object to copy properties into\n * @param source - Source object for the properties to copy\n * @param propertyObj - Object containing properties names we want to loop over\n */\nfunction deepCopyProperties(target: Record<string, any>, source: Record<string, any>, propertyObj: Record<string, any>): void {\n    for (const prop in propertyObj) {\n        if (Array.isArray(source[prop])) {\n            target[prop] = source[prop].slice();\n        } else {\n            target[prop] = source[prop];\n        }\n    }\n}\n","import { settings } from '@pixi/settings';\n\nimport type { TextStyle, TextStyleWhiteSpace } from './TextStyle';\n\ninterface IFontMetrics\n{\n    ascent: number;\n    descent: number;\n    fontSize: number;\n}\n\ntype CharacterWidthCache = { [key: string]: number };\n\n// Default settings used for all getContext calls\nconst contextSettings = {\n    // TextMetrics requires getImageData readback for measuring fonts.\n    willReadFrequently: true,\n} as CanvasRenderingContext2DSettings;\n\n/**\n * The TextMetrics object represents the measurement of a block of text with a specified style.\n *\n * ```js\n * let style = new PIXI.TextStyle({fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'})\n * let textMetrics = PIXI.TextMetrics.measureText('Your text', style)\n * ```\n * @memberof PIXI\n */\nexport class TextMetrics\n{\n    /** The text that was measured. */\n    public text: string;\n\n    /** The style that was measured. */\n    public style: TextStyle;\n\n    /** The measured width of the text. */\n    public width: number;\n\n    /** The measured height of the text. */\n    public height: number;\n\n    /** An array of lines of the text broken by new lines and wrapping is specified in style. */\n    public lines: string[];\n\n    /** An array of the line widths for each line matched to `lines`. */\n    public lineWidths: number[];\n\n    /** The measured line height for this style. */\n    public lineHeight: number;\n\n    /** The maximum line width for all measured lines. */\n    public maxLineWidth: number;\n\n    /**\n     * The font properties object from TextMetrics.measureFont.\n     * @type {PIXI.IFontMetrics}\n     */\n    public fontProperties: IFontMetrics;\n\n    public static METRICS_STRING: string;\n    public static BASELINE_SYMBOL: string;\n    public static BASELINE_MULTIPLIER: number;\n    public static HEIGHT_MULTIPLIER: number;\n\n    private static __canvas: HTMLCanvasElement | OffscreenCanvas;\n    private static __context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;\n\n    // TODO: These should be protected but they're initialized outside of the class.\n    public static _fonts: { [font: string]: IFontMetrics };\n    public static _newlines: number[];\n    public static _breakingSpaces: number[];\n\n    /**\n     * @param text - the text that was measured\n     * @param style - the style that was measured\n     * @param width - the measured width of the text\n     * @param height - the measured height of the text\n     * @param lines - an array of the lines of text broken by new lines and wrapping if specified in style\n     * @param lineWidths - an array of the line widths for each line matched to `lines`\n     * @param lineHeight - the measured line height for this style\n     * @param maxLineWidth - the maximum line width for all measured lines\n     * @param {PIXI.IFontMetrics} fontProperties - the font properties object from TextMetrics.measureFont\n     */\n    constructor(text: string, style: TextStyle, width: number, height: number, lines: string[], lineWidths: number[],\n        lineHeight: number, maxLineWidth: number, fontProperties: IFontMetrics)\n    {\n        this.text = text;\n        this.style = style;\n        this.width = width;\n        this.height = height;\n        this.lines = lines;\n        this.lineWidths = lineWidths;\n        this.lineHeight = lineHeight;\n        this.maxLineWidth = maxLineWidth;\n        this.fontProperties = fontProperties;\n    }\n\n    /**\n     * Measures the supplied string of text and returns a Rectangle.\n     * @param text - The text to measure.\n     * @param style - The text style to use for measuring\n     * @param wordWrap - Override for if word-wrap should be applied to the text.\n     * @param canvas - optional specification of the canvas to use for measuring.\n     * @returns Measured width and height of the text.\n     */\n    public static measureText(\n        text: string,\n        style: TextStyle,\n        wordWrap?: boolean,\n        canvas: HTMLCanvasElement | OffscreenCanvas = TextMetrics._canvas\n    ): TextMetrics\n    {\n        wordWrap = (wordWrap === undefined || wordWrap === null) ? style.wordWrap : wordWrap;\n        const font = style.toFontString();\n        const fontProperties = TextMetrics.measureFont(font);\n\n        // fallback in case UA disallow canvas data extraction\n        // (toDataURI, getImageData functions)\n        if (fontProperties.fontSize === 0)\n        {\n            fontProperties.fontSize = style.fontSize as number;\n            fontProperties.ascent = style.fontSize as number;\n        }\n\n        const context = canvas.getContext('2d', contextSettings);\n\n        context.font = font;\n\n        const outputText = wordWrap ? TextMetrics.wordWrap(text, style, canvas) : text;\n        const lines = outputText.split(/(?:\\r\\n|\\r|\\n)/);\n        const lineWidths = new Array<number>(lines.length);\n        let maxLineWidth = 0;\n\n        for (let i = 0; i < lines.length; i++)\n        {\n            const lineWidth = context.measureText(lines[i]).width + ((lines[i].length - 1) * style.letterSpacing);\n\n            lineWidths[i] = lineWidth;\n            maxLineWidth = Math.max(maxLineWidth, lineWidth);\n        }\n        let width = maxLineWidth + style.strokeThickness;\n\n        if (style.dropShadow)\n        {\n            width += style.dropShadowDistance;\n        }\n\n        const lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;\n        let height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness)\n            + ((lines.length - 1) * (lineHeight + style.leading));\n\n        if (style.dropShadow)\n        {\n            height += style.dropShadowDistance;\n        }\n\n        return new TextMetrics(\n            text,\n            style,\n            width,\n            height,\n            lines,\n            lineWidths,\n            lineHeight + style.leading,\n            maxLineWidth,\n            fontProperties\n        );\n    }\n\n    /**\n     * Applies newlines to a string to have it optimally fit into the horizontal\n     * bounds set by the Text object's wordWrapWidth property.\n     * @param text - String to apply word wrapping to\n     * @param style - the style to use when wrapping\n     * @param canvas - optional specification of the canvas to use for measuring.\n     * @returns New string with new lines applied where required\n     */\n    private static wordWrap(\n        text: string,\n        style: TextStyle,\n        canvas: HTMLCanvasElement | OffscreenCanvas = TextMetrics._canvas\n    ): string\n    {\n        const context = canvas.getContext('2d', contextSettings);\n\n        let width = 0;\n        let line = '';\n        let lines = '';\n\n        const cache: CharacterWidthCache = Object.create(null);\n        const { letterSpacing, whiteSpace } = style;\n\n        // How to handle whitespaces\n        const collapseSpaces = TextMetrics.collapseSpaces(whiteSpace);\n        const collapseNewlines = TextMetrics.collapseNewlines(whiteSpace);\n\n        // whether or not spaces may be added to the beginning of lines\n        let canPrependSpaces = !collapseSpaces;\n\n        // There is letterSpacing after every char except the last one\n        // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!\n        // so for convenience the above needs to be compared to width + 1 extra letterSpace\n        // t_h_i_s_' '_i_s_' '_a_n_' '_e_x_a_m_p_l_e_' '_!_\n        // ________________________________________________\n        // And then the final space is simply no appended to each line\n        const wordWrapWidth = style.wordWrapWidth + letterSpacing;\n\n        // break text into words, spaces and newline chars\n        const tokens = TextMetrics.tokenize(text);\n\n        for (let i = 0; i < tokens.length; i++)\n        {\n            // get the word, space or newlineChar\n            let token = tokens[i];\n\n            // if word is a new line\n            if (TextMetrics.isNewline(token))\n            {\n                // keep the new line\n                if (!collapseNewlines)\n                {\n                    lines += TextMetrics.addLine(line);\n                    canPrependSpaces = !collapseSpaces;\n                    line = '';\n                    width = 0;\n                    continue;\n                }\n\n                // if we should collapse new lines\n                // we simply convert it into a space\n                token = ' ';\n            }\n\n            // if we should collapse repeated whitespaces\n            if (collapseSpaces)\n            {\n                // check both this and the last tokens for spaces\n                const currIsBreakingSpace = TextMetrics.isBreakingSpace(token);\n                const lastIsBreakingSpace = TextMetrics.isBreakingSpace(line[line.length - 1]);\n\n                if (currIsBreakingSpace && lastIsBreakingSpace)\n                {\n                    continue;\n                }\n            }\n\n            // get word width from cache if possible\n            const tokenWidth = TextMetrics.getFromCache(token, letterSpacing, cache, context);\n\n            // word is longer than desired bounds\n            if (tokenWidth > wordWrapWidth)\n            {\n                // if we are not already at the beginning of a line\n                if (line !== '')\n                {\n                    // start newlines for overflow words\n                    lines += TextMetrics.addLine(line);\n                    line = '';\n                    width = 0;\n                }\n\n                // break large word over multiple lines\n                if (TextMetrics.canBreakWords(token, style.breakWords))\n                {\n                    // break word into characters\n                    const characters = TextMetrics.wordWrapSplit(token);\n\n                    // loop the characters\n                    for (let j = 0; j < characters.length; j++)\n                    {\n                        let char = characters[j];\n\n                        let k = 1;\n                        // we are not at the end of the token\n\n                        while (characters[j + k])\n                        {\n                            const nextChar = characters[j + k];\n                            const lastChar = char[char.length - 1];\n\n                            // should not split chars\n                            if (!TextMetrics.canBreakChars(lastChar, nextChar, token, j, style.breakWords))\n                            {\n                                // combine chars & move forward one\n                                char += nextChar;\n                            }\n                            else\n                            {\n                                break;\n                            }\n\n                            k++;\n                        }\n\n                        j += char.length - 1;\n\n                        const characterWidth = TextMetrics.getFromCache(char, letterSpacing, cache, context);\n\n                        if (characterWidth + width > wordWrapWidth)\n                        {\n                            lines += TextMetrics.addLine(line);\n                            canPrependSpaces = false;\n                            line = '';\n                            width = 0;\n                        }\n\n                        line += char;\n                        width += characterWidth;\n                    }\n                }\n\n                // run word out of the bounds\n                else\n                {\n                    // if there are words in this line already\n                    // finish that line and start a new one\n                    if (line.length > 0)\n                    {\n                        lines += TextMetrics.addLine(line);\n                        line = '';\n                        width = 0;\n                    }\n\n                    const isLastToken = i === tokens.length - 1;\n\n                    // give it its own line if it's not the end\n                    lines += TextMetrics.addLine(token, !isLastToken);\n                    canPrependSpaces = false;\n                    line = '';\n                    width = 0;\n                }\n            }\n\n            // word could fit\n            else\n            {\n                // word won't fit because of existing words\n                // start a new line\n                if (tokenWidth + width > wordWrapWidth)\n                {\n                    // if its a space we don't want it\n                    canPrependSpaces = false;\n\n                    // add a new line\n                    lines += TextMetrics.addLine(line);\n\n                    // start a new line\n                    line = '';\n                    width = 0;\n                }\n\n                // don't add spaces to the beginning of lines\n                if (line.length > 0 || !TextMetrics.isBreakingSpace(token) || canPrependSpaces)\n                {\n                    // add the word to the current line\n                    line += token;\n\n                    // update width counter\n                    width += tokenWidth;\n                }\n            }\n        }\n\n        lines += TextMetrics.addLine(line, false);\n\n        return lines;\n    }\n\n    /**\n     * Convienience function for logging each line added during the wordWrap method.\n     * @param line    - The line of text to add\n     * @param newLine - Add new line character to end\n     * @returns A formatted line\n     */\n    private static addLine(line: string, newLine = true): string\n    {\n        line = TextMetrics.trimRight(line);\n\n        line = (newLine) ? `${line}\\n` : line;\n\n        return line;\n    }\n\n    /**\n     * Gets & sets the widths of calculated characters in a cache object\n     * @param key            - The key\n     * @param letterSpacing  - The letter spacing\n     * @param cache          - The cache\n     * @param context        - The canvas context\n     * @returns The from cache.\n     */\n    private static getFromCache(key: string, letterSpacing: number, cache: CharacterWidthCache,\n        context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): number\n    {\n        let width = cache[key];\n\n        if (typeof width !== 'number')\n        {\n            const spacing = ((key.length) * letterSpacing);\n\n            width = context.measureText(key).width + spacing;\n            cache[key] = width;\n        }\n\n        return width;\n    }\n\n    /**\n     * Determines whether we should collapse breaking spaces.\n     * @param whiteSpace - The TextStyle property whiteSpace\n     * @returns Should collapse\n     */\n    private static collapseSpaces(whiteSpace: TextStyleWhiteSpace): boolean\n    {\n        return (whiteSpace === 'normal' || whiteSpace === 'pre-line');\n    }\n\n    /**\n     * Determines whether we should collapse newLine chars.\n     * @param whiteSpace - The white space\n     * @returns  should collapse\n     */\n    private static collapseNewlines(whiteSpace: TextStyleWhiteSpace): boolean\n    {\n        return (whiteSpace === 'normal');\n    }\n\n    /**\n     * Trims breaking whitespaces from string.\n     * @param  text - The text\n     * @returns Trimmed string\n     */\n    private static trimRight(text: string): string\n    {\n        if (typeof text !== 'string')\n        {\n            return '';\n        }\n\n        for (let i = text.length - 1; i >= 0; i--)\n        {\n            const char = text[i];\n\n            if (!TextMetrics.isBreakingSpace(char))\n            {\n                break;\n            }\n\n            text = text.slice(0, -1);\n        }\n\n        return text;\n    }\n\n    /**\n     * Determines if char is a newline.\n     * @param  char - The character\n     * @returns True if newline, False otherwise.\n     */\n    private static isNewline(char: string): boolean\n    {\n        if (typeof char !== 'string')\n        {\n            return false;\n        }\n\n        return (TextMetrics._newlines.indexOf(char.charCodeAt(0)) >= 0);\n    }\n\n    /**\n     * Determines if char is a breaking whitespace.\n     *\n     * It allows one to determine whether char should be a breaking whitespace\n     * For example certain characters in CJK langs or numbers.\n     * It must return a boolean.\n     * @param char - The character\n     * @param [_nextChar] - The next character\n     * @returns True if whitespace, False otherwise.\n     */\n    static isBreakingSpace(char: string, _nextChar?: string): boolean\n    {\n        if (typeof char !== 'string')\n        {\n            return false;\n        }\n\n        return (TextMetrics._breakingSpaces.indexOf(char.charCodeAt(0)) >= 0);\n    }\n\n    /**\n     * Splits a string into words, breaking-spaces and newLine characters\n     * @param  text - The text\n     * @returns  A tokenized array\n     */\n    private static tokenize(text: string): string[]\n    {\n        const tokens: string[] = [];\n        let token = '';\n\n        if (typeof text !== 'string')\n        {\n            return tokens;\n        }\n\n        for (let i = 0; i < text.length; i++)\n        {\n            const char = text[i];\n            const nextChar = text[i + 1];\n\n            if (TextMetrics.isBreakingSpace(char, nextChar) || TextMetrics.isNewline(char))\n            {\n                if (token !== '')\n                {\n                    tokens.push(token);\n                    token = '';\n                }\n\n                tokens.push(char);\n\n                continue;\n            }\n\n            token += char;\n        }\n\n        if (token !== '')\n        {\n            tokens.push(token);\n        }\n\n        return tokens;\n    }\n\n    /**\n     * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.\n     *\n     * It allows one to customise which words should break\n     * Examples are if the token is CJK or numbers.\n     * It must return a boolean.\n     * @param _token - The token\n     * @param  breakWords - The style attr break words\n     * @returns Whether to break word or not\n     */\n    static canBreakWords(_token: string, breakWords: boolean): boolean\n    {\n        return breakWords;\n    }\n\n    /**\n     * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.\n     *\n     * It allows one to determine whether a pair of characters\n     * should be broken by newlines\n     * For example certain characters in CJK langs or numbers.\n     * It must return a boolean.\n     * @param _char - The character\n     * @param _nextChar - The next character\n     * @param _token - The token/word the characters are from\n     * @param _index - The index in the token of the char\n     * @param _breakWords - The style attr break words\n     * @returns whether to break word or not\n     */\n    static canBreakChars(_char: string, _nextChar: string, _token: string, _index: number,\n        _breakWords: boolean): boolean\n    {\n        return true;\n    }\n\n    /**\n     * Overridable helper method used internally by TextMetrics, exposed to allow customizing the class's behavior.\n     *\n     * It is called when a token (usually a word) has to be split into separate pieces\n     * in order to determine the point to break a word.\n     * It must return an array of characters.\n     * @example\n     * // Correctly splits emojis, eg \"🤪🤪\" will result in two element array, each with one emoji.\n     * TextMetrics.wordWrapSplit = (token) => [...token];\n     * @param  token - The token to split\n     * @returns The characters of the token\n     */\n    static wordWrapSplit(token: string): string[]\n    {\n        return token.split('');\n    }\n\n    /**\n     * Calculates the ascent, descent and fontSize of a given font-style\n     * @param font - String representing the style of the font\n     * @returns Font properties object\n     */\n    public static measureFont(font: string): IFontMetrics\n    {\n        // as this method is used for preparing assets, don't recalculate things if we don't need to\n        if (TextMetrics._fonts[font])\n        {\n            return TextMetrics._fonts[font];\n        }\n\n        const properties: IFontMetrics = {\n            ascent: 0,\n            descent: 0,\n            fontSize: 0,\n        };\n\n        const canvas = TextMetrics._canvas;\n        const context = TextMetrics._context;\n\n        context.font = font;\n\n        const metricsString = TextMetrics.METRICS_STRING + TextMetrics.BASELINE_SYMBOL;\n        const width = Math.ceil(context.measureText(metricsString).width);\n        let baseline = Math.ceil(context.measureText(TextMetrics.BASELINE_SYMBOL).width);\n        const height = Math.ceil(TextMetrics.HEIGHT_MULTIPLIER * baseline);\n\n        baseline = baseline * TextMetrics.BASELINE_MULTIPLIER | 0;\n\n        canvas.width = width;\n        canvas.height = height;\n\n        context.fillStyle = '#f00';\n        context.fillRect(0, 0, width, height);\n\n        context.font = font;\n\n        context.textBaseline = 'alphabetic';\n        context.fillStyle = '#000';\n        context.fillText(metricsString, 0, baseline);\n\n        const imagedata = context.getImageData(0, 0, width, height).data;\n        const pixels = imagedata.length;\n        const line = width * 4;\n\n        let i = 0;\n        let idx = 0;\n        let stop = false;\n\n        // ascent. scan from top to bottom until we find a non red pixel\n        for (i = 0; i < baseline; ++i)\n        {\n            for (let j = 0; j < line; j += 4)\n            {\n                if (imagedata[idx + j] !== 255)\n                {\n                    stop = true;\n                    break;\n                }\n            }\n            if (!stop)\n            {\n                idx += line;\n            }\n            else\n            {\n                break;\n            }\n        }\n\n        properties.ascent = baseline - i;\n\n        idx = pixels - line;\n        stop = false;\n\n        // descent. scan from bottom to top until we find a non red pixel\n        for (i = height; i > baseline; --i)\n        {\n            for (let j = 0; j < line; j += 4)\n            {\n                if (imagedata[idx + j] !== 255)\n                {\n                    stop = true;\n                    break;\n                }\n            }\n\n            if (!stop)\n            {\n                idx -= line;\n            }\n            else\n            {\n                break;\n            }\n        }\n\n        properties.descent = i - baseline;\n        properties.fontSize = properties.ascent + properties.descent;\n\n        TextMetrics._fonts[font] = properties;\n\n        return properties;\n    }\n\n    /**\n     * Clear font metrics in metrics cache.\n     * @param {string} [font] - font name. If font name not set then clear cache for all fonts.\n     */\n    public static clearMetrics(font = ''): void\n    {\n        if (font)\n        {\n            delete TextMetrics._fonts[font];\n        }\n        else\n        {\n            TextMetrics._fonts = {};\n        }\n    }\n\n    /**\n     * Cached canvas element for measuring text\n     * TODO: this should be private, but isn't because of backward compat, will fix later.\n     * @ignore\n     */\n    public static get _canvas(): HTMLCanvasElement | OffscreenCanvas\n    {\n        if (!TextMetrics.__canvas)\n        {\n            let canvas: HTMLCanvasElement | OffscreenCanvas;\n\n            try\n            {\n                // OffscreenCanvas2D measureText can be up to 40% faster.\n                const c = new OffscreenCanvas(0, 0);\n                const context = c.getContext('2d', contextSettings);\n\n                if (context && context.measureText)\n                {\n                    TextMetrics.__canvas = c;\n\n                    return c;\n                }\n\n                canvas = settings.ADAPTER.createCanvas();\n            }\n            catch (ex)\n            {\n                canvas = settings.ADAPTER.createCanvas();\n            }\n            canvas.width = canvas.height = 10;\n            TextMetrics.__canvas = canvas;\n        }\n\n        return TextMetrics.__canvas;\n    }\n\n    /**\n     * TODO: this should be private, but isn't because of backward compat, will fix later.\n     * @ignore\n     */\n    public static get _context(): CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D\n    {\n        if (!TextMetrics.__context)\n        {\n            TextMetrics.__context = TextMetrics._canvas.getContext('2d', contextSettings);\n        }\n\n        return TextMetrics.__context;\n    }\n}\n\n/**\n * Internal return object for {@link PIXI.TextMetrics.measureFont `TextMetrics.measureFont`}.\n * @typedef {object} FontMetrics\n * @property {number} ascent - The ascent distance\n * @property {number} descent - The descent distance\n * @property {number} fontSize - Font size from ascent to descent\n * @memberof PIXI.TextMetrics\n * @private\n */\n\n/**\n * Cache of {@see PIXI.TextMetrics.FontMetrics} objects.\n * @memberof PIXI.TextMetrics\n * @type {object}\n * @private\n */\nTextMetrics._fonts = {};\n\n/**\n * String used for calculate font metrics.\n * These characters are all tall to help calculate the height required for text.\n * @static\n * @memberof PIXI.TextMetrics\n * @name METRICS_STRING\n * @type {string}\n * @default |ÉqÅ\n */\nTextMetrics.METRICS_STRING = '|ÉqÅ';\n\n/**\n * Baseline symbol for calculate font metrics.\n * @static\n * @memberof PIXI.TextMetrics\n * @name BASELINE_SYMBOL\n * @type {string}\n * @default M\n */\nTextMetrics.BASELINE_SYMBOL = 'M';\n\n/**\n * Baseline multiplier for calculate font metrics.\n * @static\n * @memberof PIXI.TextMetrics\n * @name BASELINE_MULTIPLIER\n * @type {number}\n * @default 1.4\n */\nTextMetrics.BASELINE_MULTIPLIER = 1.4;\n\n/**\n * Height multiplier for setting height of canvas to calculate font metrics.\n * @static\n * @memberof PIXI.TextMetrics\n * @name HEIGHT_MULTIPLIER\n * @type {number}\n * @default 2.00\n */\nTextMetrics.HEIGHT_MULTIPLIER = 2.0;\n\n/**\n * Cache of new line chars.\n * @memberof PIXI.TextMetrics\n * @type {number[]}\n * @private\n */\nTextMetrics._newlines = [\n    0x000A, // line feed\n    0x000D, // carriage return\n];\n\n/**\n * Cache of breaking spaces.\n * @memberof PIXI.TextMetrics\n * @type {number[]}\n * @private\n */\nTextMetrics._breakingSpaces = [\n    0x0009, // character tabulation\n    0x0020, // space\n    0x2000, // en quad\n    0x2001, // em quad\n    0x2002, // en space\n    0x2003, // em space\n    0x2004, // three-per-em space\n    0x2005, // four-per-em space\n    0x2006, // six-per-em space\n    0x2008, // punctuation space\n    0x2009, // thin space\n    0x200A, // hair space\n    0x205F, // medium mathematical space\n    0x3000, // ideographic space\n];\n\n/**\n * A number, or a string containing a number.\n * @memberof PIXI\n * @typedef {object} IFontMetrics\n * @property {number} ascent - Font ascent\n * @property {number} descent - Font descent\n * @property {number} fontSize - Font size\n */\n","/* eslint max-depth: [2, 8] */\nimport { Sprite } from '@pixi/sprite';\nimport { Texture  } from '@pixi/core';\nimport { settings } from '@pixi/settings';\nimport { Rectangle } from '@pixi/math';\nimport { sign, trimCanvas, hex2rgb, string2hex } from '@pixi/utils';\nimport { TEXT_GRADIENT } from './const';\nimport { TextStyle } from './TextStyle';\nimport { TextMetrics } from './TextMetrics';\n\nimport type { IDestroyOptions } from '@pixi/display';\nimport type { Renderer } from '@pixi/core';\nimport type { ITextStyle } from './TextStyle';\n\nconst defaultDestroyOptions: IDestroyOptions = {\n    texture: true,\n    children: false,\n    baseTexture: true,\n};\n\ninterface ModernContext2D extends CanvasRenderingContext2D\n{\n    // for chrome less 94\n    textLetterSpacing?: number;\n    // for chrome greater 94\n    letterSpacing?: number;\n}\n\n/**\n * A Text Object will create a line or multiple lines of text.\n *\n * The text is created using the [Canvas API](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API).\n *\n * The primary advantage of this class over BitmapText is that you have great control over the style of the text,\n * which you can change at runtime.\n *\n * The primary disadvantages is that each piece of text has it's own texture, which can use more memory.\n * When text changes, this texture has to be re-generated and re-uploaded to the GPU, taking up time.\n *\n * To split a line you can use '\\n' in your text string, or, on the `style` object,\n * change its `wordWrap` property to true and and give the `wordWrapWidth` property a value.\n *\n * A Text can be created directly from a string and a style object,\n * which can be generated [here](https://pixijs.io/pixi-text-style).\n *\n * ```js\n * let text = new PIXI.Text('This is a PixiJS text',{fontFamily : 'Arial', fontSize: 24, fill : 0xff1010, align : 'center'});\n * ```\n * @memberof PIXI\n */\nexport class Text extends Sprite\n{\n    /**\n     * New behavior for `lineHeight` that's meant to mimic HTML text. A value of `true` will\n     * make sure the first baseline is offset by the `lineHeight` value if it is greater than `fontSize`.\n     * A value of `false` will use the legacy behavior and not change the baseline of the first line.\n     * In the next major release, we'll enable this by default.\n     */\n    public static nextLineHeightBehavior = false;\n\n    /**\n     * New rendering behavior for letter-spacing which uses Chrome's new native API. This will\n     * lead to more accurate letter-spacing results because it does not try to manually draw\n     * each character. However, this Chrome API is experimental and may not serve all cases yet.\n     */\n    public static experimentalLetterSpacing = false;\n\n    /** The canvas element that everything is drawn to. */\n    public canvas: HTMLCanvasElement;\n    /** The canvas 2d context that everything is drawn with. */\n    public context: ModernContext2D;\n    public localStyleID: number;\n    public dirty: boolean;\n\n    /**\n     * The resolution / device pixel ratio of the canvas.\n     *\n     * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.\n     * @default PIXI.settings.RESOLUTION\n     */\n    _resolution: number;\n    _autoResolution: boolean;\n\n    /**\n     * Private tracker for the current text.\n     * @private\n     */\n    protected _text: string;\n\n    /**\n     * Private tracker for the current font.\n     * @private\n     */\n    protected _font: string;\n\n    /**\n     * Private tracker for the current style.\n     * @private\n     */\n    protected _style: TextStyle;\n\n    /**\n     * Private listener to track style changes.\n     * @private\n     */\n    protected _styleListener: () => void;\n\n    /**\n     * Keep track if this Text object created it's own canvas\n     * element (`true`) or uses the constructor argument (`false`).\n     * Used to workaround a GC issues with Safari < 13 when\n     * destroying Text. See `destroy` for more info.\n     */\n    private _ownCanvas: boolean;\n\n    /**\n     * @param text - The string that you would like the text to display\n     * @param {object|PIXI.TextStyle} [style] - The style parameters\n     * @param canvas - The canvas element for drawing text\n     */\n    constructor(text?: string | number, style?: Partial<ITextStyle> | TextStyle, canvas?: HTMLCanvasElement)\n    {\n        let ownCanvas = false;\n\n        if (!canvas)\n        {\n            canvas = settings.ADAPTER.createCanvas();\n            ownCanvas = true;\n        }\n\n        canvas.width = 3;\n        canvas.height = 3;\n\n        const texture = Texture.from(canvas);\n\n        texture.orig = new Rectangle();\n        texture.trim = new Rectangle();\n\n        super(texture);\n\n        this._ownCanvas = ownCanvas;\n        this.canvas = canvas;\n        this.context = canvas.getContext('2d', {\n            // required for trimming to work without warnings\n            willReadFrequently: true,\n        }) as CanvasRenderingContext2D;\n\n        this._resolution = settings.RESOLUTION;\n        this._autoResolution = true;\n        this._text = null;\n        this._style = null;\n        this._styleListener = null;\n        this._font = '';\n\n        this.text = text;\n        this.style = style;\n\n        this.localStyleID = -1;\n    }\n\n    /**\n     * Renders text to its canvas, and updates its texture.\n     *\n     * By default this is used internally to ensure the texture is correct before rendering,\n     * but it can be used called externally, for example from this class to 'pre-generate' the texture from a piece of text,\n     * and then shared across multiple Sprites.\n     * @param respectDirty - Whether to abort updating the text if the Text isn't dirty and the function is called.\n     */\n    public updateText(respectDirty: boolean): void\n    {\n        const style = this._style;\n\n        // check if style has changed..\n        if (this.localStyleID !== style.styleID)\n        {\n            this.dirty = true;\n            this.localStyleID = style.styleID;\n        }\n\n        if (!this.dirty && respectDirty)\n        {\n            return;\n        }\n\n        this._font = this._style.toFontString();\n\n        const context = this.context;\n        const measured = TextMetrics.measureText(this._text || ' ', this._style, this._style.wordWrap, this.canvas);\n        const width = measured.width;\n        const height = measured.height;\n        const lines = measured.lines;\n        const lineHeight = measured.lineHeight;\n        const lineWidths = measured.lineWidths;\n        const maxLineWidth = measured.maxLineWidth;\n        const fontProperties = measured.fontProperties;\n\n        this.canvas.width = Math.ceil(Math.ceil((Math.max(1, width) + (style.padding * 2))) * this._resolution);\n        this.canvas.height = Math.ceil(Math.ceil((Math.max(1, height) + (style.padding * 2))) * this._resolution);\n\n        context.scale(this._resolution, this._resolution);\n\n        context.clearRect(0, 0, this.canvas.width, this.canvas.height);\n\n        context.font = this._font;\n        context.lineWidth = style.strokeThickness;\n        context.textBaseline = style.textBaseline;\n        context.lineJoin = style.lineJoin;\n        context.miterLimit = style.miterLimit;\n\n        let linePositionX: number;\n        let linePositionY: number;\n\n        // require 2 passes if a shadow; the first to draw the drop shadow, the second to draw the text\n        const passesCount = style.dropShadow ? 2 : 1;\n\n        // For v4, we drew text at the colours of the drop shadow underneath the normal text. This gave the correct zIndex,\n        // but features such as alpha and shadowblur did not look right at all, since we were using actual text as a shadow.\n        //\n        // For v5.0.0, we moved over to just use the canvas API for drop shadows, which made them look much nicer and more\n        // visually please, but now because the stroke is drawn and then the fill, drop shadows would appear on both the fill\n        // and the stroke; and fill drop shadows would appear over the top of the stroke.\n        //\n        // For v5.1.1, the new route is to revert to v4 style of drawing text first to get the drop shadows underneath normal\n        // text, but instead drawing text in the correct location, we'll draw it off screen (-paddingY), and then adjust the\n        // drop shadow so only that appears on screen (+paddingY). Now we'll have the correct draw order of the shadow\n        // beneath the text, whilst also having the proper text shadow styling.\n        for (let i = 0; i < passesCount; ++i)\n        {\n            const isShadowPass = style.dropShadow && i === 0;\n            // we only want the drop shadow, so put text way off-screen\n            const dsOffsetText = isShadowPass ? Math.ceil(Math.max(1, height) + (style.padding * 2)) : 0;\n            const dsOffsetShadow = dsOffsetText * this._resolution;\n\n            if (isShadowPass)\n            {\n                // On Safari, text with gradient and drop shadows together do not position correctly\n                // if the scale of the canvas is not 1: https://bugs.webkit.org/show_bug.cgi?id=197689\n                // Therefore we'll set the styles to be a plain black whilst generating this drop shadow\n                context.fillStyle = 'black';\n                context.strokeStyle = 'black';\n\n                const dropShadowColor = style.dropShadowColor;\n                const rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));\n                const dropShadowBlur = style.dropShadowBlur * this._resolution;\n                const dropShadowDistance = style.dropShadowDistance * this._resolution;\n\n                context.shadowColor = `rgba(${rgb[0] * 255},${rgb[1] * 255},${rgb[2] * 255},${style.dropShadowAlpha})`;\n                context.shadowBlur = dropShadowBlur;\n                context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;\n                context.shadowOffsetY = (Math.sin(style.dropShadowAngle) * dropShadowDistance) + dsOffsetShadow;\n            }\n            else\n            {\n                // set canvas text styles\n                context.fillStyle = this._generateFillStyle(style, lines, measured);\n                // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as\n                //       the setter converts to string. See this thread for more details:\n                //       https://github.com/microsoft/TypeScript/issues/2521\n                context.strokeStyle = style.stroke as string;\n\n                context.shadowColor = 'black';\n                context.shadowBlur = 0;\n                context.shadowOffsetX = 0;\n                context.shadowOffsetY = 0;\n            }\n\n            let linePositionYShift = (lineHeight - fontProperties.fontSize) / 2;\n\n            if (!Text.nextLineHeightBehavior || lineHeight - fontProperties.fontSize < 0)\n            {\n                linePositionYShift = 0;\n            }\n\n            // draw lines line by line\n            for (let i = 0; i < lines.length; i++)\n            {\n                linePositionX = style.strokeThickness / 2;\n                linePositionY = ((style.strokeThickness / 2) + (i * lineHeight)) + fontProperties.ascent\n                    + linePositionYShift;\n\n                if (style.align === 'right')\n                {\n                    linePositionX += maxLineWidth - lineWidths[i];\n                }\n                else if (style.align === 'center')\n                {\n                    linePositionX += (maxLineWidth - lineWidths[i]) / 2;\n                }\n\n                if (style.stroke && style.strokeThickness)\n                {\n                    this.drawLetterSpacing(\n                        lines[i],\n                        linePositionX + style.padding,\n                        linePositionY + style.padding - dsOffsetText,\n                        true\n                    );\n                }\n\n                if (style.fill)\n                {\n                    this.drawLetterSpacing(\n                        lines[i],\n                        linePositionX + style.padding,\n                        linePositionY + style.padding - dsOffsetText\n                    );\n                }\n            }\n        }\n\n        this.updateTexture();\n    }\n\n    /**\n     * Render the text with letter-spacing.\n     * @param text - The text to draw\n     * @param x - Horizontal position to draw the text\n     * @param y - Vertical position to draw the text\n     * @param isStroke - Is this drawing for the outside stroke of the\n     *  text? If not, it's for the inside fill\n     */\n    private drawLetterSpacing(text: string, x: number, y: number, isStroke = false): void\n    {\n        const style = this._style;\n\n        // letterSpacing of 0 means normal\n        const letterSpacing = style.letterSpacing;\n\n        // Checking that we can use moddern canvas2D api\n        // https://developer.chrome.com/origintrials/#/view_trial/3585991203293757441\n        // note: this is unstable API, Chrome less 94 use a `textLetterSpacing`, newest use a letterSpacing\n        // eslint-disable-next-line max-len\n        const supportLetterSpacing = Text.experimentalLetterSpacing\n            && ('letterSpacing' in CanvasRenderingContext2D.prototype\n                || 'textLetterSpacing' in CanvasRenderingContext2D.prototype);\n\n        if (letterSpacing === 0 || supportLetterSpacing)\n        {\n            if (supportLetterSpacing)\n            {\n                this.context.letterSpacing = letterSpacing;\n                this.context.textLetterSpacing = letterSpacing;\n            }\n\n            if (isStroke)\n            {\n                this.context.strokeText(text, x, y);\n            }\n            else\n            {\n                this.context.fillText(text, x, y);\n            }\n\n            return;\n        }\n\n        let currentPosition = x;\n\n        // Using Array.from correctly splits characters whilst keeping emoji together.\n        // This is not supported on IE as it requires ES6, so regular text splitting occurs.\n        // This also doesn't account for emoji that are multiple emoji put together to make something else.\n        // Handling all of this would require a big library itself.\n        // https://medium.com/@giltayar/iterating-over-emoji-characters-the-es6-way-f06e4589516\n        // https://github.com/orling/grapheme-splitter\n        const stringArray = Array.from ? Array.from(text) : text.split('');\n        let previousWidth = this.context.measureText(text).width;\n        let currentWidth = 0;\n\n        for (let i = 0; i < stringArray.length; ++i)\n        {\n            const currentChar = stringArray[i];\n\n            if (isStroke)\n            {\n                this.context.strokeText(currentChar, currentPosition, y);\n            }\n            else\n            {\n                this.context.fillText(currentChar, currentPosition, y);\n            }\n            let textStr = '';\n\n            for (let j = i + 1; j < stringArray.length; ++j)\n            {\n                textStr += stringArray[j];\n            }\n            currentWidth = this.context.measureText(textStr).width;\n            currentPosition += previousWidth - currentWidth + letterSpacing;\n            previousWidth = currentWidth;\n        }\n    }\n\n    /** Updates texture size based on canvas size. */\n    private updateTexture(): void\n    {\n        const canvas = this.canvas;\n\n        if (this._style.trim)\n        {\n            const trimmed = trimCanvas(canvas);\n\n            if (trimmed.data)\n            {\n                canvas.width = trimmed.width;\n                canvas.height = trimmed.height;\n                this.context.putImageData(trimmed.data, 0, 0);\n            }\n        }\n\n        const texture = this._texture;\n        const style = this._style;\n        const padding = style.trim ? 0 : style.padding;\n        const baseTexture = texture.baseTexture;\n\n        texture.trim.width = texture._frame.width = canvas.width / this._resolution;\n        texture.trim.height = texture._frame.height = canvas.height / this._resolution;\n        texture.trim.x = -padding;\n        texture.trim.y = -padding;\n\n        texture.orig.width = texture._frame.width - (padding * 2);\n        texture.orig.height = texture._frame.height - (padding * 2);\n\n        // call sprite onTextureUpdate to update scale if _width or _height were set\n        this._onTextureUpdate();\n\n        baseTexture.setRealSize(canvas.width, canvas.height, this._resolution);\n\n        texture.updateUvs();\n\n        this.dirty = false;\n    }\n\n    /**\n     * Renders the object using the WebGL renderer\n     * @param renderer - The renderer\n     */\n    protected _render(renderer: Renderer): void\n    {\n        if (this._autoResolution && this._resolution !== renderer.resolution)\n        {\n            this._resolution = renderer.resolution;\n            this.dirty = true;\n        }\n\n        this.updateText(true);\n\n        super._render(renderer);\n    }\n\n    /** Updates the transform on all children of this container for rendering. */\n    public updateTransform(): void\n    {\n        this.updateText(true);\n\n        super.updateTransform();\n    }\n\n    public getBounds(skipUpdate?: boolean, rect?: Rectangle): Rectangle\n    {\n        this.updateText(true);\n\n        if (this._textureID === -1)\n        {\n            // texture was updated: recalculate transforms\n            skipUpdate = false;\n        }\n\n        return super.getBounds(skipUpdate, rect);\n    }\n\n    /**\n     * Gets the local bounds of the text object.\n     * @param rect - The output rectangle.\n     * @returns The bounds.\n     */\n    public getLocalBounds(rect?: Rectangle): Rectangle\n    {\n        this.updateText(true);\n\n        return super.getLocalBounds.call(this, rect);\n    }\n\n    /** Calculates the bounds of the Text as a rectangle. The bounds calculation takes the worldTransform into account. */\n    protected _calculateBounds(): void\n    {\n        this.calculateVertices();\n        // if we have already done this on THIS frame.\n        this._bounds.addQuad(this.vertexData);\n    }\n\n    /**\n     * Generates the fill style. Can automatically generate a gradient based on the fill style being an array\n     * @param style - The style.\n     * @param lines - The lines of text.\n     * @param metrics\n     * @returns The fill style\n     */\n    private _generateFillStyle(\n        style: TextStyle, lines: string[], metrics: TextMetrics\n    ): string | CanvasGradient | CanvasPattern\n    {\n        // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as\n        //       the setter converts to string. See this thread for more details:\n        //       https://github.com/microsoft/TypeScript/issues/2521\n        const fillStyle: string | string[] | CanvasGradient | CanvasPattern = style.fill as any;\n\n        if (!Array.isArray(fillStyle))\n        {\n            return fillStyle;\n        }\n        else if (fillStyle.length === 1)\n        {\n            return fillStyle[0];\n        }\n\n        // the gradient will be evenly spaced out according to how large the array is.\n        // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75\n        let gradient: string[] | CanvasGradient;\n\n        // a dropshadow will enlarge the canvas and result in the gradient being\n        // generated with the incorrect dimensions\n        const dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;\n\n        // should also take padding into account, padding can offset the gradient\n        const padding = style.padding || 0;\n\n        const width = (this.canvas.width / this._resolution) - dropShadowCorrection - (padding * 2);\n        const height = (this.canvas.height / this._resolution) - dropShadowCorrection - (padding * 2);\n\n        // make a copy of the style settings, so we can manipulate them later\n        const fill = fillStyle.slice();\n        const fillGradientStops = style.fillGradientStops.slice();\n\n        // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75\n        if (!fillGradientStops.length)\n        {\n            const lengthPlus1 = fill.length + 1;\n\n            for (let i = 1; i < lengthPlus1; ++i)\n            {\n                fillGradientStops.push(i / lengthPlus1);\n            }\n        }\n\n        // stop the bleeding of the last gradient on the line above to the top gradient of the this line\n        // by hard defining the first gradient colour at point 0, and last gradient colour at point 1\n        fill.unshift(fillStyle[0]);\n        fillGradientStops.unshift(0);\n\n        fill.push(fillStyle[fillStyle.length - 1]);\n        fillGradientStops.push(1);\n\n        if (style.fillGradientType === TEXT_GRADIENT.LINEAR_VERTICAL)\n        {\n            // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas\n            gradient = this.context.createLinearGradient(width / 2, padding, width / 2, height + padding);\n\n            // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect\n            // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875\n\n            // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc\n            const textHeight = metrics.fontProperties.fontSize + style.strokeThickness;\n\n            for (let i = 0; i < lines.length; i++)\n            {\n                const lastLineBottom = (metrics.lineHeight * (i - 1)) + textHeight;\n                const thisLineTop = metrics.lineHeight * i;\n                let thisLineGradientStart = thisLineTop;\n\n                // Handle case where last & this line overlap\n                if (i > 0 && lastLineBottom > thisLineTop)\n                {\n                    thisLineGradientStart = (thisLineTop + lastLineBottom) / 2;\n                }\n\n                const thisLineBottom = thisLineTop + textHeight;\n                const nextLineTop = metrics.lineHeight * (i + 1);\n                let thisLineGradientEnd = thisLineBottom;\n\n                // Handle case where this & next line overlap\n                if (i + 1 < lines.length && nextLineTop < thisLineBottom)\n                {\n                    thisLineGradientEnd = (thisLineBottom + nextLineTop) / 2;\n                }\n\n                // textHeight, but as a 0-1 size in global gradient stop space\n                const gradStopLineHeight = (thisLineGradientEnd - thisLineGradientStart) / height;\n\n                for (let j = 0; j < fill.length; j++)\n                {\n                    // 0-1 stop point for the current line, multiplied to global space afterwards\n                    let lineStop = 0;\n\n                    if (typeof fillGradientStops[j] === 'number')\n                    {\n                        lineStop = fillGradientStops[j];\n                    }\n                    else\n                    {\n                        lineStop = j / fill.length;\n                    }\n\n                    let globalStop = Math.min(1, Math.max(0,\n                        (thisLineGradientStart / height) + (lineStop * gradStopLineHeight)));\n\n                    // There's potential for floating point precision issues at the seams between gradient repeats.\n                    globalStop = Number(globalStop.toFixed(5));\n                    gradient.addColorStop(globalStop, fill[j]);\n                }\n            }\n        }\n        else\n        {\n            // start the gradient at the center left of the canvas, and end at the center right of the canvas\n            gradient = this.context.createLinearGradient(padding, height / 2, width + padding, height / 2);\n\n            // can just evenly space out the gradients in this case, as multiple lines makes no difference\n            // to an even left to right gradient\n            const totalIterations = fill.length + 1;\n            let currentIteration = 1;\n\n            for (let i = 0; i < fill.length; i++)\n            {\n                let stop: number;\n\n                if (typeof fillGradientStops[i] === 'number')\n                {\n                    stop = fillGradientStops[i];\n                }\n                else\n                {\n                    stop = currentIteration / totalIterations;\n                }\n                gradient.addColorStop(stop, fill[i]);\n                currentIteration++;\n            }\n        }\n\n        return gradient;\n    }\n\n    /**\n     * Destroys this text object.\n     *\n     * Note* Unlike a Sprite, a Text object will automatically destroy its baseTexture and texture as\n     * the majority of the time the texture will not be shared with any other Sprites.\n     * @param options - Options parameter. A boolean will act as if all options\n     *  have been set to that value\n     * @param {boolean} [options.children=false] - if set to true, all the children will have their\n     *  destroy method called as well. 'options' will be passed on to those calls.\n     * @param {boolean} [options.texture=true] - Should it destroy the current texture of the sprite as well\n     * @param {boolean} [options.baseTexture=true] - Should it destroy the base texture of the sprite as well\n     */\n    public destroy(options?: IDestroyOptions | boolean): void\n    {\n        if (typeof options === 'boolean')\n        {\n            options = { children: options };\n        }\n\n        options = Object.assign({}, defaultDestroyOptions, options);\n\n        super.destroy(options);\n\n        // set canvas width and height to 0 to workaround memory leak in Safari < 13\n        // https://stackoverflow.com/questions/52532614/total-canvas-memory-use-exceeds-the-maximum-limit-safari-12\n        if (this._ownCanvas)\n        {\n            this.canvas.height = this.canvas.width = 0;\n        }\n\n        // make sure to reset the context and canvas.. dont want this hanging around in memory!\n        this.context = null;\n        this.canvas = null;\n\n        this._style = null;\n    }\n\n    /** The width of the Text, setting this will actually modify the scale to achieve the value set. */\n    get width(): number\n    {\n        this.updateText(true);\n\n        return Math.abs(this.scale.x) * this._texture.orig.width;\n    }\n\n    set width(value: number)\n    {\n        this.updateText(true);\n\n        const s = sign(this.scale.x) || 1;\n\n        this.scale.x = s * value / this._texture.orig.width;\n        this._width = value;\n    }\n\n    /** The height of the Text, setting this will actually modify the scale to achieve the value set. */\n    get height(): number\n    {\n        this.updateText(true);\n\n        return Math.abs(this.scale.y) * this._texture.orig.height;\n    }\n\n    set height(value: number)\n    {\n        this.updateText(true);\n\n        const s = sign(this.scale.y) || 1;\n\n        this.scale.y = s * value / this._texture.orig.height;\n        this._height = value;\n    }\n\n    /**\n     * Set the style of the text.\n     *\n     * Set up an event listener to listen for changes on the style object and mark the text as dirty.\n     */\n    get style(): TextStyle | Partial<ITextStyle>\n    {\n        // TODO: Can't have different types for getter and setter. The getter shouldn't have the ITextStyle\n        //       since the setter creates the TextStyle. See this thread for more details:\n        //       https://github.com/microsoft/TypeScript/issues/2521\n        return this._style;\n    }\n\n    set style(style: TextStyle | Partial<ITextStyle>)\n    {\n        style = style || {};\n\n        if (style instanceof TextStyle)\n        {\n            this._style = style;\n        }\n        else\n        {\n            this._style = new TextStyle(style);\n        }\n\n        this.localStyleID = -1;\n        this.dirty = true;\n    }\n\n    /** Set the copy for the text object. To split a line you can use '\\n'. */\n    get text(): string\n    {\n        return this._text;\n    }\n\n    set text(text: string | number)\n    {\n        text = String(text === null || text === undefined ? '' : text);\n\n        if (this._text === text)\n        {\n            return;\n        }\n        this._text = text;\n        this.dirty = true;\n    }\n\n    /**\n     * The resolution / device pixel ratio of the canvas.\n     *\n     * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.\n     * @default 1\n     */\n    get resolution(): number\n    {\n        return this._resolution;\n    }\n\n    set resolution(value: number)\n    {\n        this._autoResolution = false;\n\n        if (this._resolution === value)\n        {\n            return;\n        }\n\n        this._resolution = value;\n        this.dirty = true;\n    }\n}\n","import { settings } from '@pixi/settings';\n\n/**\n * Default number of uploads per frame using prepare plugin.\n * @static\n * @memberof PIXI.settings\n * @name UPLOADS_PER_FRAME\n * @type {number}\n * @default 4\n */\nsettings.UPLOADS_PER_FRAME = 4;\n\nexport { settings };\n","/**\n * CountLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified\n * number of items per frame.\n * @memberof PIXI\n */\nexport class CountLimiter\n{\n    /** The maximum number of items that can be prepared each frame. */\n    public maxItemsPerFrame: number;\n\n    /** The number of items that can be prepared in the current frame. */\n    public itemsLeft: number;\n\n    /**\n     * @param maxItemsPerFrame - The maximum number of items that can be prepared each frame.\n     */\n    constructor(maxItemsPerFrame: number)\n    {\n        this.maxItemsPerFrame = maxItemsPerFrame;\n        this.itemsLeft = 0;\n    }\n\n    /** Resets any counting properties to start fresh on a new frame. */\n    beginFrame(): void\n    {\n        this.itemsLeft = this.maxItemsPerFrame;\n    }\n\n    /**\n     * Checks to see if another item can be uploaded. This should only be called once per item.\n     * @returns If the item is allowed to be uploaded.\n     */\n    allowedToUpload(): boolean\n    {\n        return this.itemsLeft-- > 0;\n    }\n}\n","import { Texture, BaseTexture } from '@pixi/core';\nimport { Ticker, UPDATE_PRIORITY } from '@pixi/ticker';\nimport { settings } from '@pixi/settings';\nimport type { DisplayObject } from '@pixi/display';\nimport { Container } from '@pixi/display';\nimport { Text, TextStyle, TextMetrics } from '@pixi/text';\nimport { CountLimiter } from './CountLimiter';\n\nimport type { AbstractRenderer } from '@pixi/core';\nimport { deprecation } from '@pixi/utils';\n\ninterface IArrowFunction\n{\n    (): void;\n}\ninterface IUploadHook\n{\n    (helper: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended): boolean;\n}\n\ninterface IFindHook\n{\n    (item: any, queue: Array<any>): boolean;\n}\n\nexport interface IDisplayObjectExtended extends DisplayObject\n{\n    _textures?: Array<Texture>;\n    _texture?: Texture;\n    style?: TextStyle | Partial<TextStyle>;\n}\n\n/**\n * Built-in hook to find multiple textures from objects like AnimatedSprites.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns If a PIXI.Texture object was found.\n */\nfunction findMultipleBaseTextures(item: IDisplayObjectExtended, queue: Array<any>): boolean\n{\n    let result = false;\n\n    // Objects with multiple textures\n    if (item && item._textures && item._textures.length)\n    {\n        for (let i = 0; i < item._textures.length; i++)\n        {\n            if (item._textures[i] instanceof Texture)\n            {\n                const baseTexture = item._textures[i].baseTexture;\n\n                if (queue.indexOf(baseTexture) === -1)\n                {\n                    queue.push(baseTexture);\n                    result = true;\n                }\n            }\n        }\n    }\n\n    return result;\n}\n\n/**\n * Built-in hook to find BaseTextures from Texture.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns If a PIXI.Texture object was found.\n */\nfunction findBaseTexture(item: Texture, queue: Array<any>): boolean\n{\n    if (item.baseTexture instanceof BaseTexture)\n    {\n        const texture = item.baseTexture;\n\n        if (queue.indexOf(texture) === -1)\n        {\n            queue.push(texture);\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to find textures from objects.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns If a PIXI.Texture object was found.\n */\nfunction findTexture(item: IDisplayObjectExtended, queue: Array<any>): boolean\n{\n    if (item._texture && item._texture instanceof Texture)\n    {\n        const texture = item._texture.baseTexture;\n\n        if (queue.indexOf(texture) === -1)\n        {\n            queue.push(texture);\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to draw PIXI.Text to its texture.\n * @private\n * @param _helper - Not used by this upload handler\n * @param item - Item to check\n * @returns If item was uploaded.\n */\nfunction drawText(_helper: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended): boolean\n{\n    if (item instanceof Text)\n    {\n        // updating text will return early if it is not dirty\n        item.updateText(true);\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to calculate a text style for a PIXI.Text object.\n * @private\n * @param _helper - Not used by this upload handler\n * @param item - Item to check\n * @returns If item was uploaded.\n */\nfunction calculateTextStyle(_helper: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended): boolean\n{\n    if (item instanceof TextStyle)\n    {\n        const font = item.toFontString();\n\n        TextMetrics.measureFont(font);\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to find Text objects.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns if a PIXI.Text object was found.\n */\nfunction findText(item: IDisplayObjectExtended, queue: Array<any>): boolean\n{\n    if (item instanceof Text)\n    {\n        // push the text style to prepare it - this can be really expensive\n        if (queue.indexOf(item.style) === -1)\n        {\n            queue.push(item.style);\n        }\n        // also push the text object so that we can render it (to canvas/texture) if needed\n        if (queue.indexOf(item) === -1)\n        {\n            queue.push(item);\n        }\n        // also push the Text's texture for upload to GPU\n        const texture = item._texture.baseTexture;\n\n        if (queue.indexOf(texture) === -1)\n        {\n            queue.push(texture);\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to find TextStyle objects.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns If a PIXI.TextStyle object was found.\n */\nfunction findTextStyle(item: TextStyle, queue: Array<any>): boolean\n{\n    if (item instanceof TextStyle)\n    {\n        if (queue.indexOf(item) === -1)\n        {\n            queue.push(item);\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * The prepare manager provides functionality to upload content to the GPU.\n *\n * BasePrepare handles basic queuing functionality and is extended by\n * {@link PIXI.Prepare} and {@link PIXI.CanvasPrepare}\n * to provide preparation capabilities specific to their respective renderers.\n * @example\n * // Create a sprite\n * const sprite = PIXI.Sprite.from('something.png');\n *\n * // Load object into GPU\n * app.renderer.plugins.prepare.upload(sprite, () => {\n *\n *     //Texture(s) has been uploaded to GPU\n *     app.stage.addChild(sprite);\n *\n * })\n * @abstract\n * @memberof PIXI\n */\nexport class BasePrepare\n{\n    /**\n     * The limiter to be used to control how quickly items are prepared.\n     * @type {PIXI.CountLimiter|PIXI.TimeLimiter}\n     */\n    private limiter: CountLimiter;\n\n    /** Reference to the renderer. */\n    protected renderer: AbstractRenderer;\n\n    /**\n     * The only real difference between CanvasPrepare and Prepare is what they pass\n     * to upload hooks. That different parameter is stored here.\n     */\n    protected uploadHookHelper: any;\n\n    /** Collection of items to uploads at once. */\n    protected queue: Array<any>;\n\n    /**\n     * Collection of additional hooks for finding assets.\n     * @type {Array<Function>}\n     */\n    public addHooks: Array<any>;\n\n    /**\n     * Collection of additional hooks for processing assets.\n     * @type {Array<Function>}\n     */\n    public uploadHooks: Array<any>;\n\n    /**\n     * Callback to call after completed.\n     * @type {Array<Function>}\n     */\n    public completes: Array<any>;\n\n    /**\n     * If prepare is ticking (running).\n     * @type {boolean}\n     */\n    public ticking: boolean;\n\n    /**\n     * 'bound' call for prepareItems().\n     * @type {Function}\n     */\n    private delayedTick: IArrowFunction;\n\n    /**\n     * @param {PIXI.AbstractRenderer} renderer - A reference to the current renderer\n     */\n    constructor(renderer: AbstractRenderer)\n    {\n        this.limiter = new CountLimiter(settings.UPLOADS_PER_FRAME);\n        this.renderer = renderer;\n        this.uploadHookHelper = null;\n        this.queue = [];\n        this.addHooks = [];\n        this.uploadHooks = [];\n        this.completes = [];\n        this.ticking = false;\n        this.delayedTick = (): void =>\n        {\n            // unlikely, but in case we were destroyed between tick() and delayedTick()\n            if (!this.queue)\n            {\n                return;\n            }\n            this.prepareItems();\n        };\n\n        // hooks to find the correct texture\n        this.registerFindHook(findText);\n        this.registerFindHook(findTextStyle);\n        this.registerFindHook(findMultipleBaseTextures);\n        this.registerFindHook(findBaseTexture);\n        this.registerFindHook(findTexture);\n\n        // upload hooks\n        this.registerUploadHook(drawText);\n        this.registerUploadHook(calculateTextStyle);\n    }\n\n    /**\n     * Upload all the textures and graphics to the GPU.\n     * @method PIXI.BasePrepare#upload\n     * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text} [item] -\n     *        Container or display object to search for items to upload or the items to upload themselves,\n     *        or optionally ommitted, if items have been added using {@link PIXI.BasePrepare#add `prepare.add`}.\n     */\n    upload(item?: IDisplayObjectExtended | Container | BaseTexture | Texture): Promise<void>;\n\n    /**\n     * Use the Promise-based API instead.\n     * @method PIXI.BasePrepare#upload\n     * @deprecated since version 6.5.0\n     * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text} item -\n     *        Item to upload.\n     * @param {Function} [done] - Callback when completed.\n     */\n    upload(item?: IDisplayObjectExtended | Container | BaseTexture | Texture, done?: () => void): void;\n\n    /**\n     * Use the Promise-based API instead.\n     * @method PIXI.BasePrepare#upload\n     * @deprecated since version 6.5.0\n     * @param {Function} [done] - Callback when completed.\n     */\n    upload(done?: () => void): void;\n\n    /** @ignore */\n    upload(\n        item?: IDisplayObjectExtended | Container | BaseTexture | Texture | (() => void),\n        done?: () => void): Promise<void>\n    {\n        if (typeof item === 'function')\n        {\n            done = item as () => void;\n            item = null;\n        }\n\n        // #if _DEBUG\n        if (done)\n        {\n            deprecation('6.5.0', 'BasePrepare.upload callback is deprecated, use the return Promise instead.');\n        }\n        // #endif\n\n        return new Promise((resolve) =>\n        {\n            // If a display object, search for items\n            // that we could upload\n            if (item)\n            {\n                this.add(item as IDisplayObjectExtended | Container | BaseTexture | Texture);\n            }\n\n            // TODO: remove done callback and just use resolve\n            const complete = () =>\n            {\n                done?.();\n                resolve();\n            };\n\n            // Get the items for upload from the display\n            if (this.queue.length)\n            {\n                this.completes.push(complete);\n\n                if (!this.ticking)\n                {\n                    this.ticking = true;\n                    Ticker.system.addOnce(this.tick, this, UPDATE_PRIORITY.UTILITY);\n                }\n            }\n            else\n            {\n                complete();\n            }\n        });\n    }\n\n    /**\n     * Handle tick update\n     * @private\n     */\n    tick(): void\n    {\n        setTimeout(this.delayedTick, 0);\n    }\n\n    /**\n     * Actually prepare items. This is handled outside of the tick because it will take a while\n     * and we do NOT want to block the current animation frame from rendering.\n     * @private\n     */\n    prepareItems(): void\n    {\n        this.limiter.beginFrame();\n        // Upload the graphics\n        while (this.queue.length && this.limiter.allowedToUpload())\n        {\n            const item = this.queue[0];\n            let uploaded = false;\n\n            if (item && !item._destroyed)\n            {\n                for (let i = 0, len = this.uploadHooks.length; i < len; i++)\n                {\n                    if (this.uploadHooks[i](this.uploadHookHelper, item))\n                    {\n                        this.queue.shift();\n                        uploaded = true;\n                        break;\n                    }\n                }\n            }\n\n            if (!uploaded)\n            {\n                this.queue.shift();\n            }\n        }\n\n        // We're finished\n        if (!this.queue.length)\n        {\n            this.ticking = false;\n\n            const completes = this.completes.slice(0);\n\n            this.completes.length = 0;\n\n            for (let i = 0, len = completes.length; i < len; i++)\n            {\n                completes[i]();\n            }\n        }\n        else\n        {\n            // if we are not finished, on the next rAF do this again\n            Ticker.system.addOnce(this.tick, this, UPDATE_PRIORITY.UTILITY);\n        }\n    }\n\n    /**\n     * Adds hooks for finding items.\n     * @param {Function} addHook - Function call that takes two parameters: `item:*, queue:Array`\n     *          function must return `true` if it was able to add item to the queue.\n     * @returns Instance of plugin for chaining.\n     */\n    registerFindHook(addHook: IFindHook): this\n    {\n        if (addHook)\n        {\n            this.addHooks.push(addHook);\n        }\n\n        return this;\n    }\n\n    /**\n     * Adds hooks for uploading items.\n     * @param {Function} uploadHook - Function call that takes two parameters: `prepare:CanvasPrepare, item:*` and\n     *          function must return `true` if it was able to handle upload of item.\n     * @returns Instance of plugin for chaining.\n     */\n    registerUploadHook(uploadHook: IUploadHook): this\n    {\n        if (uploadHook)\n        {\n            this.uploadHooks.push(uploadHook);\n        }\n\n        return this;\n    }\n\n    /**\n     * Manually add an item to the uploading queue.\n     * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to\n     *        add to the queue\n     * @returns Instance of plugin for chaining.\n     */\n    add(item: IDisplayObjectExtended | Container | BaseTexture | Texture): this\n    {\n        // Add additional hooks for finding elements on special\n        // types of objects that\n        for (let i = 0, len = this.addHooks.length; i < len; i++)\n        {\n            if (this.addHooks[i](item, this.queue))\n            {\n                break;\n            }\n        }\n\n        // Get children recursively\n        if (item instanceof Container)\n        {\n            for (let i = item.children.length - 1; i >= 0; i--)\n            {\n                this.add(item.children[i]);\n            }\n        }\n\n        return this;\n    }\n\n    /** Destroys the plugin, don't use after this. */\n    destroy(): void\n    {\n        if (this.ticking)\n        {\n            Ticker.system.remove(this.tick, this);\n        }\n        this.ticking = false;\n        this.addHooks = null;\n        this.uploadHooks = null;\n        this.renderer = null;\n        this.completes = null;\n        this.queue = null;\n        this.limiter = null;\n        this.uploadHookHelper = null;\n    }\n}\n","import { BaseTexture, ExtensionType } from '@pixi/core';\nimport { Graphics } from '@pixi/graphics';\nimport type { IDisplayObjectExtended } from './BasePrepare';\nimport { BasePrepare } from './BasePrepare';\n\nimport type { AbstractRenderer, Renderer, ExtensionMetadata } from '@pixi/core';\n\n/**\n * Built-in hook to upload PIXI.Texture objects to the GPU.\n * @private\n * @param renderer - instance of the webgl renderer\n * @param item - Item to check\n * @returns If item was uploaded.\n */\nfunction uploadBaseTextures(renderer: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended | BaseTexture): boolean\n{\n    if (item instanceof BaseTexture)\n    {\n        // if the texture already has a GL texture, then the texture has been prepared or rendered\n        // before now. If the texture changed, then the changer should be calling texture.update() which\n        // reuploads the texture without need for preparing it again\n        if (!item._glTextures[(renderer as Renderer).CONTEXT_UID])\n        {\n            (renderer as Renderer).texture.bind(item);\n        }\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * Built-in hook to upload PIXI.Graphics to the GPU.\n * @private\n * @param renderer - instance of the webgl renderer\n * @param item - Item to check\n * @returns If item was uploaded.\n */\nfunction uploadGraphics(renderer: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended): boolean\n{\n    if (!(item instanceof Graphics))\n    {\n        return false;\n    }\n\n    const { geometry } = item;\n\n    // update dirty graphics to get batches\n    item.finishPoly();\n    geometry.updateBatches();\n\n    const { batches } = geometry;\n\n    // upload all textures found in styles\n    for (let i = 0; i < batches.length; i++)\n    {\n        const { texture } = batches[i].style;\n\n        if (texture)\n        {\n            uploadBaseTextures(renderer, texture.baseTexture);\n        }\n    }\n\n    // if its not batchable - update vao for particular shader\n    if (!geometry.batchable)\n    {\n        (renderer as Renderer).geometry.bind(geometry, (item as any)._resolveDirectShader((renderer as Renderer)));\n    }\n\n    return true;\n}\n\n/**\n * Built-in hook to find graphics.\n * @private\n * @param item - Display object to check\n * @param queue - Collection of items to upload\n * @returns if a PIXI.Graphics object was found.\n */\nfunction findGraphics(item: IDisplayObjectExtended, queue: Array<any>): boolean\n{\n    if (item instanceof Graphics)\n    {\n        queue.push(item);\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * The prepare plugin provides renderer-specific plugins for pre-rendering DisplayObjects. These plugins are useful for\n * asynchronously preparing and uploading to the GPU assets, textures, graphics waiting to be displayed.\n *\n * Do not instantiate this plugin directly. It is available from the `renderer.plugins` property.\n * See {@link PIXI.CanvasRenderer#plugins} or {@link PIXI.Renderer#plugins}.\n * @example\n * // Create a new application\n * const app = new PIXI.Application();\n * document.body.appendChild(app.view);\n *\n * // Don't start rendering right away\n * app.stop();\n *\n * // create a display object\n * const rect = new PIXI.Graphics()\n *     .beginFill(0x00ff00)\n *     .drawRect(40, 40, 200, 200);\n *\n * // Add to the stage\n * app.stage.addChild(rect);\n *\n * // Don't start rendering until the graphic is uploaded to the GPU\n * app.renderer.plugins.prepare.upload(app.stage, () => {\n *     app.start();\n * });\n * @memberof PIXI\n */\nexport class Prepare extends BasePrepare\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'prepare',\n        type: ExtensionType.RendererPlugin,\n    };\n\n    /**\n     * @param {PIXI.Renderer} renderer - A reference to the current renderer\n     */\n    constructor(renderer: Renderer)\n    {\n        super(renderer);\n\n        this.uploadHookHelper = this.renderer;\n\n        // Add textures and graphics to upload\n        this.registerFindHook(findGraphics);\n        this.registerUploadHook(uploadBaseTextures);\n        this.registerUploadHook(uploadGraphics);\n    }\n}\n","/**\n * TimeLimiter limits the number of items handled by a {@link PIXI.BasePrepare} to a specified\n * number of milliseconds per frame.\n * @memberof PIXI\n */\nexport class TimeLimiter\n{\n    /** The maximum milliseconds that can be spent preparing items each frame. */\n    public maxMilliseconds: number;\n\n    /**\n     * The start time of the current frame.\n     * @readonly\n     */\n    public frameStart: number;\n\n    /** @param maxMilliseconds - The maximum milliseconds that can be spent preparing items each frame. */\n    constructor(maxMilliseconds: number)\n    {\n        this.maxMilliseconds = maxMilliseconds;\n        this.frameStart = 0;\n    }\n\n    /** Resets any counting properties to start fresh on a new frame. */\n    beginFrame(): void\n    {\n        this.frameStart = Date.now();\n    }\n\n    /**\n     * Checks to see if another item can be uploaded. This should only be called once per item.\n     * @returns - If the item is allowed to be uploaded.\n     */\n    allowedToUpload(): boolean\n    {\n        return Date.now() - this.frameStart < this.maxMilliseconds;\n    }\n}\n","import { Rectangle } from '@pixi/math';\nimport { Texture, BaseTexture } from '@pixi/core';\nimport { deprecation, getResolutionOfUrl } from '@pixi/utils';\nimport type { Dict } from '@pixi/utils';\nimport type { ImageResource } from '@pixi/core';\nimport type { IPointData } from '@pixi/math';\n\n/** Represents the JSON data for a spritesheet atlas. */\nexport interface ISpritesheetFrameData\n{\n    frame: {\n        x: number;\n        y: number;\n        w: number;\n        h: number;\n    };\n    trimmed?: boolean;\n    rotated?: boolean;\n    sourceSize?: {\n        w: number;\n        h: number;\n    };\n    spriteSourceSize?: {\n        x: number;\n        y: number;\n    };\n    anchor?: IPointData;\n}\n\n/** Atlas format. */\nexport interface ISpritesheetData\n{\n    frames: Dict<ISpritesheetFrameData>;\n    animations?: Dict<string[]>;\n    meta: {\n        scale: string;\n        // eslint-disable-next-line camelcase\n        related_multi_packs?: string[];\n    };\n}\n\n/**\n * Utility class for maintaining reference to a collection\n * of Textures on a single Spritesheet.\n *\n * To access a sprite sheet from your code you may pass its JSON data file to Pixi's loader:\n *\n * ```js\n * PIXI.Loader.shared.add(\"images/spritesheet.json\").load(setup);\n *\n * function setup() {\n *   let sheet = PIXI.Loader.shared.resources[\"images/spritesheet.json\"].spritesheet;\n *   ...\n * }\n * ```\n *\n * Alternately, you may circumvent the loader by instantiating the Spritesheet directly:\n * ```js\n * const sheet = new PIXI.Spritesheet(texture, spritesheetData);\n * await sheet.parse();\n * console.log('Spritesheet ready to use!');\n * ```\n *\n * With the `sheet.textures` you can create Sprite objects,`sheet.animations` can be used to create an AnimatedSprite.\n *\n * Sprite sheets can be packed using tools like {@link https://codeandweb.com/texturepacker|TexturePacker},\n * {@link https://renderhjs.net/shoebox/|Shoebox} or {@link https://github.com/krzysztof-o/spritesheet.js|Spritesheet.js}.\n * Default anchor points (see {@link PIXI.Texture#defaultAnchor}) and grouping of animation sprites are currently only\n * supported by TexturePacker.\n * @memberof PIXI\n */\nexport class Spritesheet\n{\n    /** The maximum number of Textures to build per process. */\n    static readonly BATCH_SIZE = 1000;\n\n    /** For multi-packed spritesheets, this contains a reference to all the other spritesheets it depends on. */\n    public linkedSheets: Spritesheet[] = [];\n\n    /** Reference to ths source texture. */\n    public baseTexture: BaseTexture;\n\n    /**\n     * A map containing all textures of the sprite sheet.\n     * Can be used to create a {@link PIXI.Sprite|Sprite}:\n     * ```js\n     * new PIXI.Sprite(sheet.textures[\"image.png\"]);\n     * ```\n     */\n    public textures: Dict<Texture>;\n\n    /**\n     * A map containing the textures for each animation.\n     * Can be used to create an {@link PIXI.AnimatedSprite|AnimatedSprite}:\n     * ```js\n     * new PIXI.AnimatedSprite(sheet.animations[\"anim_name\"])\n     * ```\n     */\n    public animations: Dict<Texture[]>;\n\n    /**\n     * Reference to the original JSON data.\n     * @type {object}\n     */\n    public data: ISpritesheetData;\n\n    /** The resolution of the spritesheet. */\n    public resolution: number;\n\n    /**\n     * Reference to original source image from the Loader. This reference is retained so we\n     * can destroy the Texture later on. It is never used internally.\n     */\n    private _texture: Texture;\n\n    /**\n     * Map of spritesheet frames.\n     * @type {object}\n     */\n    private _frames: Dict<ISpritesheetFrameData>;\n\n    /** Collection of frame names. */\n    private _frameKeys: string[];\n\n    /** Current batch index being processed. */\n    private _batchIndex: number;\n\n    /**\n     * Callback when parse is completed.\n     * @type {Function}\n     */\n    private _callback: (textures: Dict<Texture>) => void;\n\n    /**\n     * @param texture - Reference to the source BaseTexture object.\n     * @param {object} data - Spritesheet image data.\n     * @param resolutionFilename - The filename to consider when determining\n     *        the resolution of the spritesheet. If not provided, the imageUrl will\n     *        be used on the BaseTexture.\n     */\n    constructor(texture: BaseTexture | Texture, data: ISpritesheetData, resolutionFilename: string = null)\n    {\n        this._texture = texture instanceof Texture ? texture : null;\n        this.baseTexture = texture instanceof BaseTexture ? texture : this._texture.baseTexture;\n        this.textures = {};\n        this.animations = {};\n        this.data = data;\n\n        const resource = this.baseTexture.resource as ImageResource;\n\n        this.resolution = this._updateResolution(resolutionFilename || (resource ? resource.url : null));\n        this._frames = this.data.frames;\n        this._frameKeys = Object.keys(this._frames);\n        this._batchIndex = 0;\n        this._callback = null;\n    }\n\n    /**\n     * Generate the resolution from the filename or fallback\n     * to the meta.scale field of the JSON data.\n     * @param resolutionFilename - The filename to use for resolving\n     *        the default resolution.\n     * @returns Resolution to use for spritesheet.\n     */\n    private _updateResolution(resolutionFilename: string = null): number\n    {\n        const { scale } = this.data.meta;\n\n        // Use a defaultValue of `null` to check if a url-based resolution is set\n        let resolution = getResolutionOfUrl(resolutionFilename, null);\n\n        // No resolution found via URL\n        if (resolution === null)\n        {\n            // Use the scale value or default to 1\n            resolution = scale !== undefined ? parseFloat(scale) : 1;\n        }\n\n        // For non-1 resolutions, update baseTexture\n        if (resolution !== 1)\n        {\n            this.baseTexture.setResolution(resolution);\n        }\n\n        return resolution;\n    }\n\n    /**\n     * Parser spritesheet from loaded data. This is done asynchronously\n     * to prevent creating too many Texture within a single process.\n     * @method PIXI.Spritesheet#parse\n     */\n    public parse(): Promise<Dict<Texture>>;\n\n    /**\n     * Please use the Promise-based version of this function.\n     * @method PIXI.Spritesheet#parse\n     * @deprecated since version 6.5.0\n     * @param {Function} callback - Callback when complete returns\n     *        a map of the Textures for this spritesheet.\n     */\n    public parse(callback?: (textures?: Dict<Texture>) => void): void;\n\n    /** @ignore */\n    public parse(callback?: (textures?: Dict<Texture>) => void): Promise<Dict<Texture>>\n    {\n        // #if _DEBUG\n        if (callback)\n        {\n            deprecation('6.5.0', 'Spritesheet.parse callback is deprecated, use the return Promise instead.');\n        }\n        // #endif\n\n        return new Promise((resolve) =>\n        {\n            this._callback = (textures: Dict<Texture>) =>\n            {\n                callback?.(textures);\n                resolve(textures);\n            };\n            this._batchIndex = 0;\n\n            if (this._frameKeys.length <= Spritesheet.BATCH_SIZE)\n            {\n                this._processFrames(0);\n                this._processAnimations();\n                this._parseComplete();\n            }\n            else\n            {\n                this._nextBatch();\n            }\n        });\n    }\n\n    /**\n     * Process a batch of frames\n     * @param initialFrameIndex - The index of frame to start.\n     */\n    private _processFrames(initialFrameIndex: number): void\n    {\n        let frameIndex = initialFrameIndex;\n        const maxFrames = Spritesheet.BATCH_SIZE;\n\n        while (frameIndex - initialFrameIndex < maxFrames && frameIndex < this._frameKeys.length)\n        {\n            const i = this._frameKeys[frameIndex];\n            const data = this._frames[i];\n            const rect = data.frame;\n\n            if (rect)\n            {\n                let frame = null;\n                let trim = null;\n                const sourceSize = data.trimmed !== false && data.sourceSize\n                    ? data.sourceSize : data.frame;\n\n                const orig = new Rectangle(\n                    0,\n                    0,\n                    Math.floor(sourceSize.w) / this.resolution,\n                    Math.floor(sourceSize.h) / this.resolution\n                );\n\n                if (data.rotated)\n                {\n                    frame = new Rectangle(\n                        Math.floor(rect.x) / this.resolution,\n                        Math.floor(rect.y) / this.resolution,\n                        Math.floor(rect.h) / this.resolution,\n                        Math.floor(rect.w) / this.resolution\n                    );\n                }\n                else\n                {\n                    frame = new Rectangle(\n                        Math.floor(rect.x) / this.resolution,\n                        Math.floor(rect.y) / this.resolution,\n                        Math.floor(rect.w) / this.resolution,\n                        Math.floor(rect.h) / this.resolution\n                    );\n                }\n\n                //  Check to see if the sprite is trimmed\n                if (data.trimmed !== false && data.spriteSourceSize)\n                {\n                    trim = new Rectangle(\n                        Math.floor(data.spriteSourceSize.x) / this.resolution,\n                        Math.floor(data.spriteSourceSize.y) / this.resolution,\n                        Math.floor(rect.w) / this.resolution,\n                        Math.floor(rect.h) / this.resolution\n                    );\n                }\n\n                this.textures[i] = new Texture(\n                    this.baseTexture,\n                    frame,\n                    orig,\n                    trim,\n                    data.rotated ? 2 : 0,\n                    data.anchor\n                );\n\n                // lets also add the frame to pixi's global cache for 'from' and 'fromLoader' functions\n                Texture.addToCache(this.textures[i], i);\n            }\n\n            frameIndex++;\n        }\n    }\n\n    /** Parse animations config. */\n    private _processAnimations(): void\n    {\n        const animations = this.data.animations || {};\n\n        for (const animName in animations)\n        {\n            this.animations[animName] = [];\n            for (let i = 0; i < animations[animName].length; i++)\n            {\n                const frameName = animations[animName][i];\n\n                this.animations[animName].push(this.textures[frameName]);\n            }\n        }\n    }\n\n    /** The parse has completed. */\n    private _parseComplete(): void\n    {\n        const callback = this._callback;\n\n        this._callback = null;\n        this._batchIndex = 0;\n        callback.call(this, this.textures);\n    }\n\n    /** Begin the next batch of textures. */\n    private _nextBatch(): void\n    {\n        this._processFrames(this._batchIndex * Spritesheet.BATCH_SIZE);\n        this._batchIndex++;\n        setTimeout(() =>\n        {\n            if (this._batchIndex * Spritesheet.BATCH_SIZE < this._frameKeys.length)\n            {\n                this._nextBatch();\n            }\n            else\n            {\n                this._processAnimations();\n                this._parseComplete();\n            }\n        }, 0);\n    }\n\n    /**\n     * Destroy Spritesheet and don't use after this.\n     * @param {boolean} [destroyBase=false] - Whether to destroy the base texture as well\n     */\n    public destroy(destroyBase = false): void\n    {\n        for (const i in this.textures)\n        {\n            this.textures[i].destroy();\n        }\n        this._frames = null;\n        this._frameKeys = null;\n        this.data = null;\n        this.textures = null;\n        if (destroyBase)\n        {\n            this._texture?.destroy();\n            this.baseTexture.destroy();\n        }\n        this._texture = null;\n        this.baseTexture = null;\n        this.linkedSheets = [];\n    }\n}\n\n/**\n * Reference to Spritesheet object created.\n * @member {PIXI.Spritesheet} spritesheet\n * @memberof PIXI.LoaderResource\n * @instance\n */\n\n/**\n * Dictionary of textures from Spritesheet.\n * @member {Object<string, PIXI.Texture>} textures\n * @memberof PIXI.LoaderResource\n * @instance\n */\n","import { url } from '@pixi/utils';\nimport { Spritesheet } from './Spritesheet';\nimport { LoaderResource } from '@pixi/loaders';\nimport type { Loader } from '@pixi/loaders';\nimport type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\n\n/**\n * {@link PIXI.Loader} middleware for loading texture atlases that have been created with\n * TexturePacker or similar JSON-based spritesheet.\n *\n * This middleware automatically generates Texture resources.\n *\n * If you're using Webpack or other bundlers and plan on bundling the atlas' JSON,\n * use the {@link PIXI.Spritesheet} class to directly parse the JSON.\n *\n * The Loader's image Resource name is automatically appended with `\"_image\"`.\n * If a Resource with this name is already loaded, the Loader will skip parsing the\n * Spritesheet. The code below will generate an internal Loader Resource called `\"myatlas_image\"`.\n * @example\n * loader.add('myatlas', 'path/to/myatlas.json');\n * loader.load(() => {\n *   loader.resources.myatlas; // atlas JSON resource\n *   loader.resources.myatlas_image; // atlas Image resource\n * });\n * @memberof PIXI\n */\nexport class SpritesheetLoader\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Loader;\n\n    /**\n     * Called after a resource is loaded.\n     * @see PIXI.Loader.loaderMiddleware\n     * @param resource\n     * @param next\n     */\n    static use(resource: LoaderResource, next: (...args: unknown[]) => void): void\n    {\n        // because this is middleware, it execute in loader context. `this` = loader\n        const loader = (this as any) as Loader;\n        const imageResourceName = `${resource.name}_image`;\n\n        // skip if no data, its not json, it isn't spritesheet data, or the image resource already exists\n        if (!resource.data\n            || resource.type !== LoaderResource.TYPE.JSON\n            || !resource.data.frames\n            || loader.resources[imageResourceName]\n        )\n        {\n            next();\n\n            return;\n        }\n\n        // Check and add the multi atlas\n        // Heavily influenced and based on https://github.com/rocket-ua/pixi-tps-loader/blob/master/src/ResourceLoader.js\n        // eslint-disable-next-line camelcase\n        const multiPacks = resource.data?.meta?.related_multi_packs;\n\n        if (Array.isArray(multiPacks))\n        {\n            for (const item of multiPacks)\n            {\n                if (typeof item !== 'string')\n                {\n                    continue;\n                }\n\n                const itemName = item.replace('.json', '');\n                const itemUrl = url.resolve(resource.url.replace(loader.baseUrl, ''), item);\n\n                // Check if the file wasn't already added as multipacks are redundant\n                if (loader.resources[itemName]\n                    || Object.values(loader.resources).some((r) => url.format(url.parse(r.url)) === itemUrl))\n                {\n                    continue;\n                }\n\n                const options = {\n                    crossOrigin: resource.crossOrigin,\n                    loadType: LoaderResource.LOAD_TYPE.XHR,\n                    xhrType: LoaderResource.XHR_RESPONSE_TYPE.JSON,\n                    parentResource: resource,\n                    metadata: resource.metadata\n                };\n\n                loader.add(itemName, itemUrl, options);\n            }\n        }\n\n        const loadOptions = {\n            crossOrigin: resource.crossOrigin,\n            metadata: resource.metadata.imageMetadata,\n            parentResource: resource,\n        };\n\n        const resourcePath = SpritesheetLoader.getResourcePath(resource, loader.baseUrl);\n\n        // load the image for this sheet\n        loader.add(imageResourceName, resourcePath, loadOptions, function onImageLoad(res: LoaderResource)\n        {\n            if (res.error)\n            {\n                next(res.error);\n\n                return;\n            }\n\n            const spritesheet = new Spritesheet(\n                res.texture,\n                resource.data,\n                resource.url\n            );\n\n            spritesheet.parse().then(() =>\n            {\n                resource.spritesheet = spritesheet;\n                resource.textures = spritesheet.textures;\n                next();\n            });\n        });\n    }\n\n    /**\n     * Get the spritesheets root path\n     * @param resource - Resource to check path\n     * @param baseUrl - Base root url\n     */\n    static getResourcePath(resource: LoaderResource, baseUrl: string): string\n    {\n        // Prepend url path unless the resource image is a data url\n        if (resource.isDataUrl)\n        {\n            return resource.data.meta.image;\n        }\n\n        return url.resolve(resource.url.replace(baseUrl, ''), resource.data.meta.image);\n    }\n}\n","import { Texture, TextureMatrix } from '@pixi/core';\nimport { Point, Rectangle, Transform  } from '@pixi/math';\nimport { Sprite } from '@pixi/sprite';\nimport type { Renderer, IBaseTextureOptions, TextureSource } from '@pixi/core';\nimport type { IDestroyOptions } from '@pixi/display';\nimport type { IPoint, IPointData, ISize, ObservablePoint } from '@pixi/math';\n\nconst tempPoint = new Point();\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface TilingSprite extends GlobalMixins.TilingSprite {}\n\n/**\n * A tiling sprite is a fast way of rendering a tiling image.\n * @memberof PIXI\n */\nexport class TilingSprite extends Sprite\n{\n    /** Tile transform */\n    public tileTransform: Transform;\n\n    /** Matrix that is applied to UV to get the coords in Texture normalized space to coords in BaseTexture space. */\n    public uvMatrix: TextureMatrix;\n\n    /**\n     * Flags whether the tiling pattern should originate from the origin instead of the top-left corner in\n     * local space.\n     *\n     * This will make the texture coordinates assigned to each vertex dependent on the value of the anchor. Without\n     * this, the top-left corner always gets the (0, 0) texture coordinate.\n     * @default false\n     */\n    public uvRespectAnchor: boolean;\n\n    /**\n     * @param texture - The texture of the tiling sprite.\n     * @param width - The width of the tiling sprite.\n     * @param height - The height of the tiling sprite.\n     */\n    constructor(texture: Texture, width = 100, height = 100)\n    {\n        super(texture);\n\n        this.tileTransform = new Transform();\n\n        // The width of the tiling sprite\n        this._width = width;\n\n        // The height of the tiling sprite\n        this._height = height;\n\n        this.uvMatrix = this.texture.uvMatrix || new TextureMatrix(texture);\n\n        /**\n         * Plugin that is responsible for rendering this element.\n         * Allows to customize the rendering process without overriding '_render' method.\n         * @default 'tilingSprite'\n         */\n        this.pluginName = 'tilingSprite';\n\n        this.uvRespectAnchor = false;\n    }\n    /**\n     * Changes frame clamping in corresponding textureTransform, shortcut\n     * Change to -0.5 to add a pixel to the edge, recommended for transparent trimmed textures in atlas\n     * @default 0.5\n     * @member {number}\n     */\n    get clampMargin(): number\n    {\n        return this.uvMatrix.clampMargin;\n    }\n\n    set clampMargin(value: number)\n    {\n        this.uvMatrix.clampMargin = value;\n        this.uvMatrix.update(true);\n    }\n\n    /** The scaling of the image that is being tiled. */\n    get tileScale(): ObservablePoint\n    {\n        return this.tileTransform.scale;\n    }\n\n    set tileScale(value: IPointData)\n    {\n        this.tileTransform.scale.copyFrom(value as IPoint);\n    }\n\n    /** The offset of the image that is being tiled. */\n    get tilePosition(): ObservablePoint\n    {\n        return this.tileTransform.position;\n    }\n\n    set tilePosition(value: ObservablePoint)\n    {\n        this.tileTransform.position.copyFrom(value as IPoint);\n    }\n\n    /**\n     * @protected\n     */\n    protected _onTextureUpdate(): void\n    {\n        if (this.uvMatrix)\n        {\n            this.uvMatrix.texture = this._texture;\n        }\n        this._cachedTint = 0xFFFFFF;\n    }\n\n    /**\n     * Renders the object using the WebGL renderer\n     * @param renderer - The renderer\n     */\n    protected _render(renderer: Renderer): void\n    {\n        // tweak our texture temporarily..\n        const texture = this._texture;\n\n        if (!texture || !texture.valid)\n        {\n            return;\n        }\n\n        this.tileTransform.updateLocalTransform();\n        this.uvMatrix.update();\n\n        renderer.batch.setObjectRenderer(renderer.plugins[this.pluginName]);\n        renderer.plugins[this.pluginName].render(this);\n    }\n\n    /** Updates the bounds of the tiling sprite. */\n    protected _calculateBounds(): void\n    {\n        const minX = this._width * -this._anchor._x;\n        const minY = this._height * -this._anchor._y;\n        const maxX = this._width * (1 - this._anchor._x);\n        const maxY = this._height * (1 - this._anchor._y);\n\n        this._bounds.addFrame(this.transform, minX, minY, maxX, maxY);\n    }\n\n    /**\n     * Gets the local bounds of the sprite object.\n     * @param rect - Optional output rectangle.\n     * @returns The bounds.\n     */\n    public getLocalBounds(rect?: Rectangle): Rectangle\n    {\n        // we can do a fast local bounds if the sprite has no children!\n        if (this.children.length === 0)\n        {\n            this._bounds.minX = this._width * -this._anchor._x;\n            this._bounds.minY = this._height * -this._anchor._y;\n            this._bounds.maxX = this._width * (1 - this._anchor._x);\n            this._bounds.maxY = this._height * (1 - this._anchor._y);\n\n            if (!rect)\n            {\n                if (!this._localBoundsRect)\n                {\n                    this._localBoundsRect = new Rectangle();\n                }\n\n                rect = this._localBoundsRect;\n            }\n\n            return this._bounds.getRectangle(rect);\n        }\n\n        return super.getLocalBounds.call(this, rect);\n    }\n\n    /**\n     * Checks if a point is inside this tiling sprite.\n     * @param point - The point to check.\n     * @returns Whether or not the sprite contains the point.\n     */\n    public containsPoint(point: IPointData): boolean\n    {\n        this.worldTransform.applyInverse(point, tempPoint);\n\n        const width = this._width;\n        const height = this._height;\n        const x1 = -width * this.anchor._x;\n\n        if (tempPoint.x >= x1 && tempPoint.x < x1 + width)\n        {\n            const y1 = -height * this.anchor._y;\n\n            if (tempPoint.y >= y1 && tempPoint.y < y1 + height)\n            {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Destroys this sprite and optionally its texture and children\n     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options\n     *  have been set to that value\n     * @param {boolean} [options.children=false] - if set to true, all the children will have their destroy\n     *      method called as well. 'options' will be passed on to those calls.\n     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well\n     * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well\n     */\n    public destroy(options?: IDestroyOptions | boolean): void\n    {\n        super.destroy(options);\n\n        this.tileTransform = null;\n        this.uvMatrix = null;\n    }\n\n    /**\n     * Helper function that creates a new tiling sprite based on the source you provide.\n     * The source can be - frame id, image url, video url, canvas element, video element, base texture\n     * @static\n     * @param {string|PIXI.Texture|HTMLCanvasElement|HTMLVideoElement} source - Source to create texture from\n     * @param {object} options - See {@link PIXI.BaseTexture}'s constructor for options.\n     * @param {number} options.width - required width of the tiling sprite\n     * @param {number} options.height - required height of the tiling sprite\n     * @returns {PIXI.TilingSprite} The newly created texture\n     */\n    static from(source: TextureSource | Texture, options: ISize & IBaseTextureOptions): TilingSprite\n    {\n        const texture = (source instanceof Texture)\n            ? source\n            : Texture.from(source, options);\n\n        return new TilingSprite(\n            texture,\n            options.width,\n            options.height\n        );\n    }\n\n    /** The width of the sprite, setting this will actually modify the scale to achieve the value set. */\n    get width(): number\n    {\n        return this._width;\n    }\n\n    set width(value: number)\n    {\n        this._width = value;\n    }\n\n    /** The height of the TilingSprite, setting this will actually modify the scale to achieve the value set. */\n    get height(): number\n    {\n        return this._height;\n    }\n\n    set height(value: number)\n    {\n        this._height = value;\n    }\n}\n","import { ObjectRenderer, Shader, State, QuadUv, ExtensionType } from '@pixi/core';\nimport { WRAP_MODES } from '@pixi/constants';\nimport { Matrix } from '@pixi/math';\nimport { premultiplyTintToRgba, correctBlendMode } from '@pixi/utils';\n\nimport fragmentSimpleSrc from './sprite-tiling-simple.frag';\nimport gl1VertexSrc from './sprite-tiling-fallback.vert';\nimport gl1FragmentSrc from './sprite-tiling-fallback.frag';\nimport gl2VertexSrc from './sprite-tiling.vert';\nimport gl2FragmentSrc from './sprite-tiling.frag';\n\nimport type { Renderer, ExtensionMetadata } from '@pixi/core';\nimport type { TilingSprite } from './TilingSprite';\n\nconst tempMat = new Matrix();\n\n/**\n * WebGL renderer plugin for tiling sprites\n * @class\n * @memberof PIXI\n * @extends PIXI.ObjectRenderer\n */\nexport class TilingSpriteRenderer extends ObjectRenderer\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'tilingSprite',\n        type: ExtensionType.RendererPlugin,\n    };\n\n    public shader: Shader;\n    public simpleShader: Shader;\n    public quad: QuadUv;\n    public readonly state: State;\n\n    /**\n     * constructor for renderer\n     * @param {PIXI.Renderer} renderer - The renderer this tiling awesomeness works for.\n     */\n    constructor(renderer: Renderer)\n    {\n        super(renderer);\n\n        // WebGL version is not available during initialization!\n        renderer.runners.contextChange.add(this);\n\n        this.quad = new QuadUv();\n\n        /**\n         * The WebGL state in which this renderer will work.\n         * @member {PIXI.State}\n         * @readonly\n         */\n        this.state = State.for2d();\n    }\n\n    /** Creates shaders when context is initialized. */\n    contextChange(): void\n    {\n        const renderer = this.renderer;\n        const uniforms = { globals: renderer.globalUniforms };\n\n        this.simpleShader = Shader.from(gl1VertexSrc, fragmentSimpleSrc, uniforms);\n        this.shader = renderer.context.webGLVersion > 1\n            ? Shader.from(gl2VertexSrc, gl2FragmentSrc, uniforms)\n            : Shader.from(gl1VertexSrc, gl1FragmentSrc, uniforms);\n    }\n\n    /**\n     * @param {PIXI.TilingSprite} ts - tilingSprite to be rendered\n     */\n    public render(ts: TilingSprite): void\n    {\n        const renderer = this.renderer;\n        const quad = this.quad;\n\n        let vertices = quad.vertices;\n\n        vertices[0] = vertices[6] = (ts._width) * -ts.anchor.x;\n        vertices[1] = vertices[3] = ts._height * -ts.anchor.y;\n\n        vertices[2] = vertices[4] = (ts._width) * (1.0 - ts.anchor.x);\n        vertices[5] = vertices[7] = ts._height * (1.0 - ts.anchor.y);\n\n        const anchorX = ts.uvRespectAnchor ? ts.anchor.x : 0;\n        const anchorY = ts.uvRespectAnchor ? ts.anchor.y : 0;\n\n        vertices = quad.uvs;\n\n        vertices[0] = vertices[6] = -anchorX;\n        vertices[1] = vertices[3] = -anchorY;\n\n        vertices[2] = vertices[4] = 1.0 - anchorX;\n        vertices[5] = vertices[7] = 1.0 - anchorY;\n\n        quad.invalidate();\n\n        const tex = ts._texture;\n        const baseTex = tex.baseTexture;\n        const premultiplied = baseTex.alphaMode > 0;\n        const lt = ts.tileTransform.localTransform;\n        const uv = ts.uvMatrix;\n        let isSimple = baseTex.isPowerOfTwo\n            && tex.frame.width === baseTex.width && tex.frame.height === baseTex.height;\n\n        // auto, force repeat wrapMode for big tiling textures\n        if (isSimple)\n        {\n            if (!baseTex._glTextures[renderer.CONTEXT_UID])\n            {\n                if (baseTex.wrapMode === WRAP_MODES.CLAMP)\n                {\n                    baseTex.wrapMode = WRAP_MODES.REPEAT;\n                }\n            }\n            else\n            {\n                isSimple = baseTex.wrapMode !== WRAP_MODES.CLAMP;\n            }\n        }\n\n        const shader = isSimple ? this.simpleShader : this.shader;\n\n        const w = tex.width;\n        const h = tex.height;\n        const W = ts._width;\n        const H = ts._height;\n\n        tempMat.set(lt.a * w / W,\n            lt.b * w / H,\n            lt.c * h / W,\n            lt.d * h / H,\n            lt.tx / W,\n            lt.ty / H);\n\n        // that part is the same as above:\n        // tempMat.identity();\n        // tempMat.scale(tex.width, tex.height);\n        // tempMat.prepend(lt);\n        // tempMat.scale(1.0 / ts._width, 1.0 / ts._height);\n\n        tempMat.invert();\n        if (isSimple)\n        {\n            tempMat.prepend(uv.mapCoord);\n        }\n        else\n        {\n            shader.uniforms.uMapCoord = uv.mapCoord.toArray(true);\n            shader.uniforms.uClampFrame = uv.uClampFrame;\n            shader.uniforms.uClampOffset = uv.uClampOffset;\n        }\n\n        shader.uniforms.uTransform = tempMat.toArray(true);\n        shader.uniforms.uColor = premultiplyTintToRgba(ts.tint, ts.worldAlpha,\n            shader.uniforms.uColor, premultiplied);\n        shader.uniforms.translationMatrix = ts.transform.worldTransform.toArray(true);\n        shader.uniforms.uSampler = tex;\n\n        renderer.shader.bind(shader);\n        renderer.geometry.bind(quad);\n\n        this.state.blendMode = correctBlendMode(ts.blendMode, premultiplied);\n        renderer.state.set(this.state);\n        renderer.geometry.draw(this.renderer.gl.TRIANGLES, 6, 0);\n    }\n}\n","/* eslint-disable max-len */\n\n/**\n * Normalized parsed data from .fnt files.\n * @memberof PIXI\n */\nexport class BitmapFontData\n{\n    /** @readonly */\n    public info: IBitmapFontDataInfo[];\n\n    /** @readonly */\n    public common: IBitmapFontDataCommon[];\n\n    /** @readonly */\n    public page: IBitmapFontDataPage[];\n\n    /** @readonly */\n    public char: IBitmapFontDataChar[];\n\n    /** @readonly */\n    public kerning: IBitmapFontDataKerning[];\n\n    /** @readonly */\n    public distanceField: IBitmapFontDataDistanceField[];\n\n    constructor()\n    {\n        this.info = [];\n        this.common = [];\n        this.page = [];\n        this.char = [];\n        this.kerning = [];\n        this.distanceField = [];\n    }\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataInfo\n{\n    /** Font face */\n    face: string;\n\n    /** Font size */\n    size: number;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataCommon\n{\n    /** Line height, in pixels. */\n    lineHeight: number;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataPage\n{\n    /** Unique id for bitmap texture */\n    id: number;\n\n    /** File name */\n    file: string;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataChar\n{\n    /** Unique id of character */\n    id: number;\n\n    /** {@link PIXI.IBitmapFontDataPage} id */\n    page: number;\n\n    /** x-position of character in page. */\n    x: number;\n\n    /** y-position of character in page. */\n    y: number;\n\n    /** Width of character in page. */\n    width: number;\n\n    /** Height of character in page. */\n    height: number;\n\n    /** x-offset to apply when rendering character */\n    xoffset: number;\n\n    /** y-offset to apply when rendering character. */\n    yoffset: number;\n\n    /** Advancement to apply to next character. */\n    xadvance: number;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataKerning\n{\n    /** First character of pair */\n    first: number;\n\n    /** Second character of pair */\n    second: number;\n\n    /** x-offset to apply between first & second characters when they are next to each other. */\n    amount: number;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontDataDistanceField\n{\n    /** Type of distance field */\n    fieldType: string;\n\n    /** Range of distance */\n    distanceRange: number;\n}\n","import { BitmapFontData } from '../BitmapFontData';\n\n/**\n * Internal data format used to convert to BitmapFontData.\n * @private\n */\nexport interface IBitmapFontRawData\n{\n    info: {\n        face: string;\n        size: string;\n    }[];\n    common: { lineHeight: string }[];\n    page: {\n        id: string;\n        file: string;\n    }[];\n    chars: {\n        count: number;\n    }[];\n    char: {\n        id: string;\n        page: string;\n        x: string;\n        y: string;\n        width: string;\n        height: string;\n        xoffset: string;\n        yoffset: string;\n        xadvance: string;\n    }[];\n    kernings?: {\n        count: number;\n    }[];\n    kerning?: {\n        first: string;\n        second: string;\n        amount: string;\n    }[];\n    distanceField?: {\n        fieldType: string;\n        distanceRange: string;\n    }[]\n}\n\n/**\n * BitmapFont format that's Text-based.\n * @private\n */\nexport class TextFormat\n{\n    /**\n     * Check if resource refers to txt font data.\n     * @param data\n     * @returns - True if resource could be treated as font data, false otherwise.\n     */\n    static test(data: unknown): boolean\n    {\n        return typeof data === 'string' && data.indexOf('info face=') === 0;\n    }\n\n    /**\n     * Convert text font data to a javascript object.\n     * @param txt - Raw string data to be converted\n     * @returns - Parsed font data\n     */\n    static parse(txt: string): BitmapFontData\n    {\n        // Retrieve data item\n        const items = txt.match(/^[a-z]+\\s+.+$/gm);\n        const rawData: IBitmapFontRawData = {\n            info: [],\n            common: [],\n            page: [],\n            char: [],\n            chars: [],\n            kerning: [],\n            kernings: [],\n            distanceField: [],\n        };\n\n        for (const i in items)\n        {\n            // Extract item name\n            const name = items[i].match(/^[a-z]+/gm)[0] as keyof BitmapFontData;\n\n            // Extract item attribute list as string ex.: \"width=10\"\n            const attributeList = items[i].match(/[a-zA-Z]+=([^\\s\"']+|\"([^\"]*)\")/gm);\n\n            // Convert attribute list into an object\n            const itemData: any = {};\n\n            for (const i in attributeList)\n            {\n                // Split key-value pairs\n                const split = attributeList[i].split('=');\n                const key = split[0];\n\n                // Remove eventual quotes from value\n                const strValue = split[1].replace(/\"/gm, '');\n\n                // Try to convert value into float\n                const floatValue = parseFloat(strValue);\n\n                // Use string value case float value is NaN\n                const value = isNaN(floatValue) ? strValue : floatValue;\n\n                itemData[key] = value;\n            }\n\n            // Push current item to the resulting data\n            rawData[name].push(itemData);\n        }\n\n        const font = new BitmapFontData();\n\n        rawData.info.forEach((info) => font.info.push({\n            face: info.face,\n            size: parseInt(info.size, 10),\n        }));\n\n        rawData.common.forEach((common) => font.common.push({\n            lineHeight: parseInt(common.lineHeight, 10),\n        }));\n\n        rawData.page.forEach((page) => font.page.push({\n            id: parseInt(page.id, 10),\n            file: page.file,\n        }));\n\n        rawData.char.forEach((char) => font.char.push({\n            id: parseInt(char.id, 10),\n            page: parseInt(char.page, 10),\n            x: parseInt(char.x, 10),\n            y: parseInt(char.y, 10),\n            width: parseInt(char.width, 10),\n            height: parseInt(char.height, 10),\n            xoffset: parseInt(char.xoffset, 10),\n            yoffset: parseInt(char.yoffset, 10),\n            xadvance: parseInt(char.xadvance, 10),\n        }));\n\n        rawData.kerning.forEach((kerning) => font.kerning.push({\n            first: parseInt(kerning.first, 10),\n            second: parseInt(kerning.second, 10),\n            amount: parseInt(kerning.amount, 10),\n        }));\n\n        rawData.distanceField.forEach((df) => font.distanceField.push({\n            distanceRange: parseInt(df.distanceRange, 10),\n            fieldType: df.fieldType,\n        }));\n\n        return font;\n    }\n}\n","import { BitmapFontData } from '../BitmapFontData';\n\n/**\n * BitmapFont format that's XML-based.\n * @private\n */\nexport class XMLFormat\n{\n    /**\n     * Check if resource refers to xml font data.\n     * @param data\n     * @returns - True if resource could be treated as font data, false otherwise.\n     */\n    static test(data: unknown): boolean\n    {\n        return data instanceof XMLDocument\n            && data.getElementsByTagName('page').length\n            && data.getElementsByTagName('info')[0].getAttribute('face') !== null;\n    }\n\n    /**\n     * Convert the XML into BitmapFontData that we can use.\n     * @param xml\n     * @returns - Data to use for BitmapFont\n     */\n    static parse(xml: XMLDocument): BitmapFontData\n    {\n        const data = new BitmapFontData();\n        const info = xml.getElementsByTagName('info');\n        const common = xml.getElementsByTagName('common');\n        const page = xml.getElementsByTagName('page');\n        const char = xml.getElementsByTagName('char');\n        const kerning = xml.getElementsByTagName('kerning');\n        const distanceField = xml.getElementsByTagName('distanceField');\n\n        for (let i = 0; i < info.length; i++)\n        {\n            data.info.push({\n                face: info[i].getAttribute('face'),\n                size: parseInt(info[i].getAttribute('size'), 10),\n            });\n        }\n\n        for (let i = 0; i < common.length; i++)\n        {\n            data.common.push({\n                lineHeight: parseInt(common[i].getAttribute('lineHeight'), 10),\n            });\n        }\n\n        for (let i = 0; i < page.length; i++)\n        {\n            data.page.push({\n                id: parseInt(page[i].getAttribute('id'), 10) || 0,\n                file: page[i].getAttribute('file'),\n            });\n        }\n\n        for (let i = 0; i < char.length; i++)\n        {\n            const letter = char[i];\n\n            data.char.push({\n                id: parseInt(letter.getAttribute('id'), 10),\n                page: parseInt(letter.getAttribute('page'), 10) || 0,\n                x: parseInt(letter.getAttribute('x'), 10),\n                y: parseInt(letter.getAttribute('y'), 10),\n                width: parseInt(letter.getAttribute('width'), 10),\n                height: parseInt(letter.getAttribute('height'), 10),\n                xoffset: parseInt(letter.getAttribute('xoffset'), 10),\n                yoffset: parseInt(letter.getAttribute('yoffset'), 10),\n                xadvance: parseInt(letter.getAttribute('xadvance'), 10),\n            });\n        }\n\n        for (let i = 0; i < kerning.length; i++)\n        {\n            data.kerning.push({\n                first: parseInt(kerning[i].getAttribute('first'), 10),\n                second: parseInt(kerning[i].getAttribute('second'), 10),\n                amount: parseInt(kerning[i].getAttribute('amount'), 10),\n            });\n        }\n\n        for (let i = 0; i < distanceField.length; i++)\n        {\n            data.distanceField.push({\n                fieldType: distanceField[i].getAttribute('fieldType'),\n                distanceRange: parseInt(distanceField[i].getAttribute('distanceRange'), 10),\n            });\n        }\n\n        return data;\n    }\n}\n","import type { BitmapFontData } from '../BitmapFontData';\nimport { XMLFormat } from './XMLFormat';\n\n/**\n * BitmapFont format that's XML-based.\n * @private\n */\nexport class XMLStringFormat\n{\n    /**\n     * Check if resource refers to text xml font data.\n     * @param data\n     * @returns - True if resource could be treated as font data, false otherwise.\n     */\n    static test(data: unknown): boolean\n    {\n        if (typeof data === 'string' && data.indexOf('<font>') > -1)\n        {\n            const xml = new globalThis.DOMParser().parseFromString(data, 'text/xml');\n\n            return XMLFormat.test(xml);\n        }\n\n        return false;\n    }\n\n    /**\n     * Convert the text XML into BitmapFontData that we can use.\n     * @param xmlTxt\n     * @returns - Data to use for BitmapFont\n     */\n    static parse(xmlTxt: string): BitmapFontData\n    {\n        const xml = new globalThis.DOMParser().parseFromString(xmlTxt, 'text/xml');\n\n        return XMLFormat.parse(xml);\n    }\n}\n","import { TextFormat } from './TextFormat';\nimport { XMLFormat } from './XMLFormat';\nimport { XMLStringFormat } from './XMLStringFormat';\n\n// Registered formats, maybe make this extensible in the future?\nconst formats = [\n    TextFormat,\n    XMLFormat,\n    XMLStringFormat,\n] as const;\n\n/**\n * Auto-detect BitmapFont parsing format based on data.\n * @private\n * @param {any} data - Data to detect format\n * @returns {any} Format or null\n */\nexport function autoDetectFormat(data: unknown): typeof formats[number] | null\n{\n    for (let i = 0; i < formats.length; i++)\n    {\n        if (formats[i].test(data))\n        {\n            return formats[i];\n        }\n    }\n\n    return null;\n}\n\nexport type { IBitmapFontRawData } from './TextFormat';\nexport { TextFormat, XMLFormat, XMLStringFormat };\n","import { generateFillStyle } from './generateFillStyle';\nimport { hex2rgb, string2hex } from '@pixi/utils';\nimport type { TextMetrics, TextStyle } from '@pixi/text';\n\n// TODO: Prevent code duplication b/w drawGlyph & Text#updateText\n\n/**\n * Draws the glyph `metrics.text` on the given canvas.\n *\n * Ignored because not directly exposed.\n * @ignore\n * @param {HTMLCanvasElement} canvas\n * @param {CanvasRenderingContext2D} context\n * @param {TextMetrics} metrics\n * @param {number} x\n * @param {number} y\n * @param {number} resolution\n * @param {TextStyle} style\n */\nexport function drawGlyph(\n    canvas: HTMLCanvasElement,\n    context: CanvasRenderingContext2D,\n    metrics: TextMetrics,\n    x: number,\n    y: number,\n    resolution: number,\n    style: TextStyle\n): void\n{\n    const char = metrics.text;\n    const fontProperties = metrics.fontProperties;\n\n    context.translate(x, y);\n    context.scale(resolution, resolution);\n\n    const tx = style.strokeThickness / 2;\n    const ty = -(style.strokeThickness / 2);\n\n    context.font = style.toFontString();\n    context.lineWidth = style.strokeThickness;\n    context.textBaseline = style.textBaseline;\n    context.lineJoin = style.lineJoin;\n    context.miterLimit = style.miterLimit;\n\n    // set canvas text styles\n    context.fillStyle = generateFillStyle(canvas, context, style, resolution, [char], metrics);\n    context.strokeStyle = style.stroke as string;\n\n    if (style.dropShadow)\n    {\n        const dropShadowColor = style.dropShadowColor;\n        const rgb = hex2rgb(typeof dropShadowColor === 'number' ? dropShadowColor : string2hex(dropShadowColor));\n        const dropShadowBlur = style.dropShadowBlur * resolution;\n        const dropShadowDistance = style.dropShadowDistance * resolution;\n\n        context.shadowColor = `rgba(${rgb[0] * 255},${rgb[1] * 255},${rgb[2] * 255},${style.dropShadowAlpha})`;\n        context.shadowBlur = dropShadowBlur;\n        context.shadowOffsetX = Math.cos(style.dropShadowAngle) * dropShadowDistance;\n        context.shadowOffsetY = Math.sin(style.dropShadowAngle) * dropShadowDistance;\n    }\n    else\n    {\n        context.shadowColor = 'black';\n        context.shadowBlur = 0;\n        context.shadowOffsetX = 0;\n        context.shadowOffsetY = 0;\n    }\n\n    if (style.stroke && style.strokeThickness)\n    {\n        context.strokeText(char, tx, ty + metrics.lineHeight - fontProperties.descent);\n    }\n    if (style.fill)\n    {\n        context.fillText(char, tx, ty + metrics.lineHeight - fontProperties.descent);\n    }\n\n    context.setTransform(1, 0, 0, 1, 0, 0); // defaults needed for older browsers (e.g. Opera 29)\n\n    context.fillStyle = 'rgba(0, 0, 0, 0)';\n}\n","import type { TextStyle, TextMetrics } from '@pixi/text';\nimport { TEXT_GRADIENT } from '@pixi/text';\n\n// TODO: Prevent code duplication b/w generateFillStyle & Text#generateFillStyle\n\n/**\n * Generates the fill style. Can automatically generate a gradient based on the fill style being an array\n * @private\n * @param canvas\n * @param context\n * @param {object} style - The style.\n * @param resolution\n * @param {string[]} lines - The lines of text.\n * @param metrics\n * @returns {string|number|CanvasGradient} The fill style\n */\nexport function generateFillStyle(\n    canvas: HTMLCanvasElement,\n    context: CanvasRenderingContext2D,\n    style: TextStyle,\n    resolution: number,\n    lines: string[],\n    metrics: TextMetrics\n): string | CanvasGradient | CanvasPattern\n{\n    // TODO: Can't have different types for getter and setter. The getter shouldn't have the number type as\n    //       the setter converts to string. See this thread for more details:\n    //       https://github.com/microsoft/TypeScript/issues/2521\n    const fillStyle: string | string[] | CanvasGradient | CanvasPattern = style.fill as any;\n\n    if (!Array.isArray(fillStyle))\n    {\n        return fillStyle;\n    }\n    else if (fillStyle.length === 1)\n    {\n        return fillStyle[0];\n    }\n\n    // the gradient will be evenly spaced out according to how large the array is.\n    // ['#FF0000', '#00FF00', '#0000FF'] would created stops at 0.25, 0.5 and 0.75\n    let gradient: string[] | CanvasGradient;\n\n    // a dropshadow will enlarge the canvas and result in the gradient being\n    // generated with the incorrect dimensions\n    const dropShadowCorrection = (style.dropShadow) ? style.dropShadowDistance : 0;\n\n    // should also take padding into account, padding can offset the gradient\n    const padding = style.padding || 0;\n\n    const width = (canvas.width / resolution) - dropShadowCorrection - (padding * 2);\n    const height = (canvas.height / resolution) - dropShadowCorrection - (padding * 2);\n\n    // make a copy of the style settings, so we can manipulate them later\n    const fill = fillStyle.slice();\n    const fillGradientStops = style.fillGradientStops.slice();\n\n    // wanting to evenly distribute the fills. So an array of 4 colours should give fills of 0.25, 0.5 and 0.75\n    if (!fillGradientStops.length)\n    {\n        const lengthPlus1 = fill.length + 1;\n\n        for (let i = 1; i < lengthPlus1; ++i)\n        {\n            fillGradientStops.push(i / lengthPlus1);\n        }\n    }\n\n    // stop the bleeding of the last gradient on the line above to the top gradient of the this line\n    // by hard defining the first gradient colour at point 0, and last gradient colour at point 1\n    fill.unshift(fillStyle[0]);\n    fillGradientStops.unshift(0);\n\n    fill.push(fillStyle[fillStyle.length - 1]);\n    fillGradientStops.push(1);\n\n    if (style.fillGradientType === TEXT_GRADIENT.LINEAR_VERTICAL)\n    {\n        // start the gradient at the top center of the canvas, and end at the bottom middle of the canvas\n        gradient = context.createLinearGradient(width / 2, padding, width / 2, height + padding);\n\n        // we need to repeat the gradient so that each individual line of text has the same vertical gradient effect\n        // ['#FF0000', '#00FF00', '#0000FF'] over 2 lines would create stops at 0.125, 0.25, 0.375, 0.625, 0.75, 0.875\n\n        // There's potential for floating point precision issues at the seams between gradient repeats.\n        // The loop below generates the stops in order, so track the last generated one to prevent\n        // floating point precision from making us go the teeniest bit backwards, resulting in\n        // the first and last colors getting swapped.\n        let lastIterationStop = 0;\n\n        // Actual height of the text itself, not counting spacing for lineHeight/leading/dropShadow etc\n        const textHeight = metrics.fontProperties.fontSize + style.strokeThickness;\n\n        // textHeight, but as a 0-1 size in global gradient stop space\n        const gradStopLineHeight = textHeight / height;\n\n        for (let i = 0; i < lines.length; i++)\n        {\n            const thisLineTop = metrics.lineHeight * i;\n\n            for (let j = 0; j < fill.length; j++)\n            {\n                // 0-1 stop point for the current line, multiplied to global space afterwards\n                let lineStop = 0;\n\n                if (typeof fillGradientStops[j] === 'number')\n                {\n                    lineStop = fillGradientStops[j];\n                }\n                else\n                {\n                    lineStop = j / fill.length;\n                }\n\n                const globalStop = (thisLineTop / height) + (lineStop * gradStopLineHeight);\n\n                // Prevent color stop generation going backwards from floating point imprecision\n                let clampedStop = Math.max(lastIterationStop, globalStop);\n\n                clampedStop = Math.min(clampedStop, 1); // Cap at 1 as well for safety's sake to avoid a possible throw.\n                gradient.addColorStop(clampedStop, fill[j]);\n                lastIterationStop = clampedStop;\n            }\n        }\n    }\n    else\n    {\n        // start the gradient at the center left of the canvas, and end at the center right of the canvas\n        gradient = context.createLinearGradient(padding, height / 2, width + padding, height / 2);\n\n        // can just evenly space out the gradients in this case, as multiple lines makes no difference\n        // to an even left to right gradient\n        const totalIterations = fill.length + 1;\n        let currentIteration = 1;\n\n        for (let i = 0; i < fill.length; i++)\n        {\n            let stop: number;\n\n            if (typeof fillGradientStops[i] === 'number')\n            {\n                stop = fillGradientStops[i];\n            }\n            else\n            {\n                stop = currentIteration / totalIterations;\n            }\n            gradient.addColorStop(stop, fill[i]);\n            currentIteration++;\n        }\n    }\n\n    return gradient;\n}\n","/**\n * Ponyfill for IE because it doesn't support `Array.from`\n * @param text\n * @private\n */\nexport function splitTextToCharacters(text: string): string[]\n{\n    return Array.from ? Array.from(text) : text.split('');\n}\n","/**\n * Ponyfill for IE because it doesn't support `codePointAt`\n * @param str\n * @private\n */\nexport function extractCharCode(str: string): number\n{\n    return str.codePointAt ? str.codePointAt(0) : str.charCodeAt(0);\n}\n","import { getResolutionOfUrl } from '@pixi/utils';\nimport { Rectangle } from '@pixi/math';\nimport { Texture, BaseTexture } from '@pixi/core';\nimport { TextStyle, TextMetrics } from '@pixi/text';\nimport { autoDetectFormat } from './formats';\nimport { BitmapFontData } from './BitmapFontData';\nimport { resolveCharacters, drawGlyph, extractCharCode } from './utils';\n\nimport type { Dict } from '@pixi/utils';\nimport type { ITextStyle } from '@pixi/text';\nimport { ALPHA_MODES, MIPMAP_MODES } from '@pixi/constants';\nimport { settings } from '@pixi/settings';\n\nexport interface IBitmapFontCharacter\n{\n    xOffset: number;\n    yOffset: number;\n    xAdvance: number;\n    texture: Texture;\n    page: number;\n    kerning: Dict<number>;\n}\n\n/** @memberof PIXI */\nexport interface IBitmapFontOptions\n{\n    /**\n     * The character set to generate.\n     * @default PIXI.BitmapFont.ALPHANUMERIC\n     */\n    chars?: string | (string | string[])[];\n\n    /**\n     * The resolution for rendering.\n     * @default 1\n     */\n    resolution?: number;\n\n    /**\n     * The padding between glyphs in the atlas.\n     * @default 4\n     */\n    padding?: number;\n\n    /**\n     * The width of the texture atlas.\n     * @default 512\n     */\n    textureWidth?: number;\n\n    /**\n     * The height of the texture atlas.\n     * @default 512\n     */\n    textureHeight?: number;\n}\n\n/**\n * BitmapFont represents a typeface available for use with the BitmapText class. Use the `install`\n * method for adding a font to be used.\n * @memberof PIXI\n */\nexport class BitmapFont\n{\n    /**\n     * This character set includes all the letters in the alphabet (both lower- and upper- case).\n     * @type {string[][]}\n     * @example\n     * BitmapFont.from(\"ExampleFont\", style, { chars: BitmapFont.ALPHA })\n     */\n    public static readonly ALPHA = [['a', 'z'], ['A', 'Z'], ' '];\n\n    /**\n     * This character set includes all decimal digits (from 0 to 9).\n     * @type {string[][]}\n     * @example\n     * BitmapFont.from(\"ExampleFont\", style, { chars: BitmapFont.NUMERIC })\n     */\n    public static readonly NUMERIC = [['0', '9']];\n\n    /**\n     * This character set is the union of `BitmapFont.ALPHA` and `BitmapFont.NUMERIC`.\n     * @type {string[][]}\n     */\n    public static readonly ALPHANUMERIC = [['a', 'z'], ['A', 'Z'], ['0', '9'], ' '];\n\n    /**\n     * This character set consists of all the ASCII table.\n     * @member {string[][]}\n     * @see http://www.asciitable.com/\n     */\n    public static readonly ASCII = [[' ', '~']];\n\n    /**\n     * Collection of default options when using `BitmapFont.from`.\n     * @property {number} [resolution=1] -\n     * @property {number} [textureWidth=512] -\n     * @property {number} [textureHeight=512] -\n     * @property {number} [padding=4] -\n     * @property {string|string[]|string[][]} chars = PIXI.BitmapFont.ALPHANUMERIC\n     */\n    public static readonly defaultOptions: IBitmapFontOptions = {\n        resolution: 1,\n        textureWidth: 512,\n        textureHeight: 512,\n        padding: 4,\n        chars: BitmapFont.ALPHANUMERIC,\n    };\n\n    /** Collection of available/installed fonts. */\n    public static readonly available: Dict<BitmapFont> = {};\n\n    /** The name of the font face. */\n    public readonly font: string;\n\n    /** The size of the font face in pixels. */\n    public readonly size: number;\n\n    /** The line-height of the font face in pixels. */\n    public readonly lineHeight: number;\n\n    /** The map of characters by character code. */\n    public readonly chars: Dict<IBitmapFontCharacter>;\n\n    /** The map of base page textures (i.e., sheets of glyphs). */\n    public readonly pageTextures: Dict<Texture>;\n\n    /** The range of the distance field in pixels. */\n    public readonly distanceFieldRange: number;\n\n    /** The kind of distance field for this font or \"none\". */\n    public readonly distanceFieldType: string;\n\n    private _ownsTextures: boolean;\n\n    /**\n     * @param data\n     * @param textures\n     * @param ownsTextures - Setting to `true` will destroy page textures\n     *        when the font is uninstalled.\n     */\n    constructor(data: BitmapFontData, textures: Texture[] | Dict<Texture>, ownsTextures?: boolean)\n    {\n        const [info] = data.info;\n        const [common] = data.common;\n        const [page] = data.page;\n        const [distanceField] = data.distanceField;\n        const res = getResolutionOfUrl(page.file);\n        const pageTextures: Dict<Texture> = {};\n\n        this._ownsTextures = ownsTextures;\n        this.font = info.face;\n        this.size = info.size;\n        this.lineHeight = common.lineHeight / res;\n        this.chars = {};\n        this.pageTextures = pageTextures;\n\n        // Convert the input Texture, Textures or object\n        // into a page Texture lookup by \"id\"\n        for (let i = 0; i < data.page.length; i++)\n        {\n            const { id, file } = data.page[i];\n\n            pageTextures[id] = textures instanceof Array\n                ? textures[i] : textures[file];\n\n            // only MSDF and SDF fonts need no-premultiplied-alpha\n            if (distanceField?.fieldType && distanceField.fieldType !== 'none')\n            {\n                pageTextures[id].baseTexture.alphaMode = ALPHA_MODES.NO_PREMULTIPLIED_ALPHA;\n                pageTextures[id].baseTexture.mipmap = MIPMAP_MODES.OFF;\n            }\n        }\n\n        // parse letters\n        for (let i = 0; i < data.char.length; i++)\n        {\n            const { id, page } = data.char[i];\n            let { x, y, width, height, xoffset, yoffset, xadvance } = data.char[i];\n\n            x /= res;\n            y /= res;\n            width /= res;\n            height /= res;\n            xoffset /= res;\n            yoffset /= res;\n            xadvance /= res;\n\n            const rect = new Rectangle(\n                x + (pageTextures[page].frame.x / res),\n                y + (pageTextures[page].frame.y / res),\n                width,\n                height\n            );\n\n            this.chars[id] = {\n                xOffset: xoffset,\n                yOffset: yoffset,\n                xAdvance: xadvance,\n                kerning: {},\n                texture: new Texture(\n                    pageTextures[page].baseTexture,\n                    rect\n                ),\n                page,\n            };\n        }\n\n        // parse kernings\n        for (let i = 0; i < data.kerning.length; i++)\n        {\n            let { first, second, amount } = data.kerning[i];\n\n            first /= res;\n            second /= res;\n            amount /= res;\n\n            if (this.chars[second])\n            {\n                this.chars[second].kerning[first] = amount;\n            }\n        }\n\n        // Store distance field information\n        this.distanceFieldRange = distanceField?.distanceRange;\n        this.distanceFieldType = distanceField?.fieldType?.toLowerCase() ?? 'none';\n    }\n\n    /** Remove references to created glyph textures. */\n    public destroy(): void\n    {\n        for (const id in this.chars)\n        {\n            this.chars[id].texture.destroy();\n            this.chars[id].texture = null;\n        }\n\n        for (const id in this.pageTextures)\n        {\n            if (this._ownsTextures)\n            {\n                this.pageTextures[id].destroy(true);\n            }\n\n            this.pageTextures[id] = null;\n        }\n\n        // Set readonly null.\n        (this as any).chars = null;\n        (this as any).pageTextures = null;\n    }\n\n    /**\n     * Register a new bitmap font.\n     * @param data - The\n     *        characters map that could be provided as xml or raw string.\n     * @param textures - List of textures for each page.\n     * @param ownsTextures - Set to `true` to destroy page textures\n     *        when the font is uninstalled. By default fonts created with\n     *        `BitmapFont.from` or from the `BitmapFontLoader` are `true`.\n     * @returns {PIXI.BitmapFont} Result font object with font, size, lineHeight\n     *         and char fields.\n     */\n    public static install(\n        data: string | XMLDocument | BitmapFontData,\n        textures: Texture | Texture[] | Dict<Texture>,\n        ownsTextures?: boolean\n    ): BitmapFont\n    {\n        let fontData;\n\n        if (data instanceof BitmapFontData)\n        {\n            fontData = data;\n        }\n        else\n        {\n            const format = autoDetectFormat(data);\n\n            if (!format)\n            {\n                throw new Error('Unrecognized data format for font.');\n            }\n\n            fontData = format.parse(data as any);\n        }\n\n        // Single texture, convert to list\n        if (textures instanceof Texture)\n        {\n            textures = [textures];\n        }\n\n        const font = new BitmapFont(fontData, textures, ownsTextures);\n\n        BitmapFont.available[font.font] = font;\n\n        return font;\n    }\n\n    /**\n     * Remove bitmap font by name.\n     * @param name - Name of the font to uninstall.\n     */\n    public static uninstall(name: string): void\n    {\n        const font = BitmapFont.available[name];\n\n        if (!font)\n        {\n            throw new Error(`No font found named '${name}'`);\n        }\n\n        font.destroy();\n        delete BitmapFont.available[name];\n    }\n\n    /**\n     * Generates a bitmap-font for the given style and character set. This does not support\n     * kernings yet. With `style` properties, only the following non-layout properties are used:\n     *\n     * - {@link PIXI.TextStyle#dropShadow|dropShadow}\n     * - {@link PIXI.TextStyle#dropShadowDistance|dropShadowDistance}\n     * - {@link PIXI.TextStyle#dropShadowColor|dropShadowColor}\n     * - {@link PIXI.TextStyle#dropShadowBlur|dropShadowBlur}\n     * - {@link PIXI.TextStyle#dropShadowAngle|dropShadowAngle}\n     * - {@link PIXI.TextStyle#fill|fill}\n     * - {@link PIXI.TextStyle#fillGradientStops|fillGradientStops}\n     * - {@link PIXI.TextStyle#fillGradientType|fillGradientType}\n     * - {@link PIXI.TextStyle#fontFamily|fontFamily}\n     * - {@link PIXI.TextStyle#fontSize|fontSize}\n     * - {@link PIXI.TextStyle#fontVariant|fontVariant}\n     * - {@link PIXI.TextStyle#fontWeight|fontWeight}\n     * - {@link PIXI.TextStyle#lineJoin|lineJoin}\n     * - {@link PIXI.TextStyle#miterLimit|miterLimit}\n     * - {@link PIXI.TextStyle#stroke|stroke}\n     * - {@link PIXI.TextStyle#strokeThickness|strokeThickness}\n     * - {@link PIXI.TextStyle#textBaseline|textBaseline}\n     * @param name - The name of the custom font to use with BitmapText.\n     * @param textStyle - Style options to render with BitmapFont.\n     * @param options - Setup options for font or name of the font.\n     * @param {string|string[]|string[][]} [options.chars=PIXI.BitmapFont.ALPHANUMERIC] - characters included\n     *      in the font set. You can also use ranges. For example, `[['a', 'z'], ['A', 'Z'], \"!@#$%^&*()~{}[] \"]`.\n     *      Don't forget to include spaces ' ' in your character set!\n     * @param {number} [options.resolution=1] - Render resolution for glyphs.\n     * @param {number} [options.textureWidth=512] - Optional width of atlas, smaller values to reduce memory.\n     * @param {number} [options.textureHeight=512] - Optional height of atlas, smaller values to reduce memory.\n     * @param {number} [options.padding=4] - Padding between glyphs on texture atlas.\n     * @returns Font generated by style options.\n     * @example\n     * PIXI.BitmapFont.from(\"TitleFont\", {\n     *     fontFamily: \"Arial\",\n     *     fontSize: 12,\n     *     strokeThickness: 2,\n     *     fill: \"purple\"\n     * });\n     *\n     * const title = new PIXI.BitmapText(\"This is the title\", { fontName: \"TitleFont\" });\n     */\n    public static from(name: string, textStyle?: TextStyle | Partial<ITextStyle>, options?: IBitmapFontOptions): BitmapFont\n    {\n        if (!name)\n        {\n            throw new Error('[BitmapFont] Property `name` is required.');\n        }\n\n        const {\n            chars,\n            padding,\n            resolution,\n            textureWidth,\n            textureHeight } = Object.assign(\n            {}, BitmapFont.defaultOptions, options);\n\n        const charsList = resolveCharacters(chars);\n        const style = textStyle instanceof TextStyle ? textStyle : new TextStyle(textStyle);\n        const lineWidth = textureWidth;\n        const fontData = new BitmapFontData();\n\n        fontData.info[0] = {\n            face: style.fontFamily as string,\n            size: style.fontSize as number,\n        };\n        fontData.common[0] = {\n            lineHeight: style.fontSize as number,\n        };\n\n        let positionX = 0;\n        let positionY = 0;\n\n        let canvas: HTMLCanvasElement;\n        let context: CanvasRenderingContext2D;\n        let baseTexture: BaseTexture;\n        let maxCharHeight = 0;\n        const baseTextures: BaseTexture[] = [];\n        const textures: Texture[] = [];\n\n        for (let i = 0; i < charsList.length; i++)\n        {\n            if (!canvas)\n            {\n                canvas = settings.ADAPTER.createCanvas();\n                canvas.width = textureWidth;\n                canvas.height = textureHeight;\n\n                context = canvas.getContext('2d');\n                baseTexture = new BaseTexture(canvas, { resolution });\n\n                baseTextures.push(baseTexture);\n                textures.push(new Texture(baseTexture));\n\n                fontData.page.push({\n                    id: textures.length - 1,\n                    file: '',\n                });\n            }\n\n            // Measure glyph dimensions\n            const character = charsList[i];\n            const metrics = TextMetrics.measureText(character, style, false, canvas);\n            const width = metrics.width;\n            const height = Math.ceil(metrics.height);\n\n            // This is ugly - but italics are given more space so they don't overlap\n            const textureGlyphWidth = Math.ceil((style.fontStyle === 'italic' ? 2 : 1) * width);\n\n            // Can't fit char anymore: next canvas please!\n            if (positionY >= textureHeight - (height * resolution))\n            {\n                if (positionY === 0)\n                {\n                    // We don't want user debugging an infinite loop (or do we? :)\n                    throw new Error(`[BitmapFont] textureHeight ${textureHeight}px is too small `\n                        + `(fontFamily: '${style.fontFamily}', fontSize: ${style.fontSize}px, char: '${character}')`);\n                }\n\n                --i;\n\n                // Create new atlas once current has filled up\n                canvas = null;\n                context = null;\n                baseTexture = null;\n                positionY = 0;\n                positionX = 0;\n                maxCharHeight = 0;\n\n                continue;\n            }\n\n            maxCharHeight = Math.max(height + metrics.fontProperties.descent, maxCharHeight);\n\n            // Wrap line once full row has been rendered\n            if ((textureGlyphWidth * resolution) + positionX >= lineWidth)\n            {\n                if (positionX === 0)\n                {\n                    // Avoid infinite loop (There can be some very wide char like '\\uFDFD'!)\n                    throw new Error(`[BitmapFont] textureWidth ${textureWidth}px is too small `\n                        + `(fontFamily: '${style.fontFamily}', fontSize: ${style.fontSize}px, char: '${character}')`);\n                }\n\n                --i;\n                positionY += maxCharHeight * resolution;\n                positionY = Math.ceil(positionY);\n                positionX = 0;\n                maxCharHeight = 0;\n\n                continue;\n            }\n\n            drawGlyph(canvas, context, metrics, positionX, positionY, resolution, style);\n\n            // Unique (numeric) ID mapping to this glyph\n            const id = extractCharCode(metrics.text);\n\n            // Create a texture holding just the glyph\n            fontData.char.push({\n                id,\n                page: textures.length - 1,\n                x: positionX / resolution,\n                y: positionY / resolution,\n                width: textureGlyphWidth,\n                height,\n                xoffset: 0,\n                yoffset: 0,\n                xadvance: Math.ceil(width\n                        - (style.dropShadow ? style.dropShadowDistance : 0)\n                        - (style.stroke ? style.strokeThickness : 0)),\n            });\n\n            positionX += (textureGlyphWidth + (2 * padding)) * resolution;\n            positionX = Math.ceil(positionX);\n        }\n\n        // Brute-force kerning info, this can be expensive b/c it's an O(n²),\n        // but we're using measureText which is native and fast.\n        for (let i = 0, len = charsList.length; i < len; i++)\n        {\n            const first = charsList[i];\n\n            for (let j = 0; j < len; j++)\n            {\n                const second = charsList[j];\n                const c1 = context.measureText(first).width;\n                const c2 = context.measureText(second).width;\n                const total = context.measureText(first + second).width;\n                const amount = total - (c1 + c2);\n\n                if (amount)\n                {\n                    fontData.kerning.push({\n                        first: extractCharCode(first),\n                        second: extractCharCode(second),\n                        amount,\n                    });\n                }\n            }\n        }\n\n        const font = new BitmapFont(fontData, textures, true);\n\n        // Make it easier to replace a font\n        if (BitmapFont.available[name] !== undefined)\n        {\n            BitmapFont.uninstall(name);\n        }\n\n        BitmapFont.available[name] = font;\n\n        return font;\n    }\n}\n","import { splitTextToCharacters } from './splitTextToCharacters';\n\n/**\n * Processes the passed character set data and returns a flattened array of all the characters.\n *\n * Ignored because not directly exposed.\n * @ignore\n * @param {string | string[] | string[][] } chars\n * @returns {string[]} the flattened array of characters\n */\nexport function resolveCharacters(chars: string | (string | string[])[]): string[]\n{\n    // Split the chars string into individual characters\n    if (typeof chars === 'string')\n    {\n        chars = [chars];\n    }\n\n    // Handle an array of characters+ranges\n    const result: string[] = [];\n\n    for (let i = 0, j = chars.length; i < j; i++)\n    {\n        const item = chars[i];\n\n        // Handle range delimited by start/end chars\n        if (Array.isArray(item))\n        {\n            if (item.length !== 2)\n            {\n                throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${item.length}.`);\n            }\n\n            const startCode = item[0].charCodeAt(0);\n            const endCode = item[1].charCodeAt(0);\n\n            if (endCode < startCode)\n            {\n                throw new Error('[BitmapFont]: Invalid character range.');\n            }\n\n            for (let i = startCode, j = endCode; i <= j; i++)\n            {\n                result.push(String.fromCharCode(i));\n            }\n        }\n        // Handle a character set string\n        else\n        {\n            result.push(...splitTextToCharacters(item));\n        }\n    }\n\n    if (result.length === 0)\n    {\n        throw new Error('[BitmapFont]: Empty set when resolving characters.');\n    }\n\n    return result;\n}\n","import { ObservablePoint, Point } from '@pixi/math';\nimport { settings } from '@pixi/settings';\nimport { Mesh, MeshGeometry, MeshMaterial } from '@pixi/mesh';\nimport { removeItems } from '@pixi/utils';\nimport { BitmapFont } from './BitmapFont';\nimport { splitTextToCharacters, extractCharCode } from './utils';\nimport msdfFrag from './shader/msdf.frag';\nimport msdfVert from './shader/msdf.vert';\nimport type { Rectangle } from '@pixi/math';\nimport type { Renderer } from '@pixi/core';\nimport { Program, Texture } from '@pixi/core';\nimport type { IBitmapTextStyle } from './BitmapTextStyle';\nimport type { TextStyleAlign } from '@pixi/text';\nimport { Container } from '@pixi/display';\nimport type { IDestroyOptions } from '@pixi/display';\nimport { BLEND_MODES } from '@pixi/constants';\n\ninterface PageMeshData\n{\n    index: number;\n    indexCount: number;\n    vertexCount: number;\n    uvsCount: number;\n    total: number;\n    mesh: Mesh;\n    vertices?: Float32Array;\n    uvs?: Float32Array;\n    indices?: Uint16Array;\n}\ninterface CharRenderData\n{\n    texture: Texture;\n    line: number;\n    charCode: number;\n    position: Point;\n    prevSpaces: number;\n}\n\n// If we ever need more than two pools, please make a Dict or something better.\nconst pageMeshDataDefaultPageMeshData: PageMeshData[] = [];\nconst pageMeshDataMSDFPageMeshData: PageMeshData[] = [];\nconst charRenderDataPool: CharRenderData[] = [];\n\n/**\n * A BitmapText object will create a line or multiple lines of text using bitmap font.\n *\n * The primary advantage of this class over Text is that all of your textures are pre-generated and loading,\n * meaning that rendering is fast, and changing text has no performance implications.\n *\n * Supporting character sets other than latin, such as CJK languages, may be impractical due to the number of characters.\n *\n * To split a line you can use '\\n', '\\r' or '\\r\\n' in your string.\n *\n * PixiJS can auto-generate fonts on-the-fly using BitmapFont or use fnt files provided by:\n * http://www.angelcode.com/products/bmfont/ for Windows or\n * http://www.bmglyph.com/ for Mac.\n *\n * You can also use SDF, MSDF and MTSDF BitmapFonts for vector-like scaling appearance provided by:\n * https://github.com/soimy/msdf-bmfont-xml for SDF and MSDF fnt files or\n * https://github.com/Chlumsky/msdf-atlas-gen for SDF, MSDF and MTSDF json files\n *\n * A BitmapText can only be created when the font is loaded.\n *\n * ```js\n * // in this case the font is in a file called 'desyrel.fnt'\n * let bitmapText = new PIXI.BitmapText(\"text using a fancy font!\", {\n *   fontName: \"Desyrel\",\n *   fontSize: 35,\n *   align: \"right\"\n * });\n * ```\n * @memberof PIXI\n */\nexport class BitmapText extends Container\n{\n    public static styleDefaults: Partial<IBitmapTextStyle> = {\n        align: 'left',\n        tint: 0xFFFFFF,\n        maxWidth: 0,\n        letterSpacing: 0,\n    };\n\n    /** Set to `true` if the BitmapText needs to be redrawn. */\n    public dirty: boolean;\n\n    /**\n     * The resolution / device pixel ratio of the canvas.\n     *\n     * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.\n     * @default PIXI.settings.RESOLUTION\n     */\n    _resolution: number;\n    _autoResolution: boolean;\n\n    /**\n     * Private tracker for the width of the overall text.\n     * @private\n     */\n    protected _textWidth: number;\n\n    /**\n     * Private tracker for the height of the overall text.\n     * @private\n     */\n    protected _textHeight: number;\n\n    /**\n     * Private tracker for the current text.\n     * @private\n     */\n    protected _text: string;\n\n    /**\n     * The max width of this bitmap text in pixels. If the text provided is longer than the\n     * value provided, line breaks will be automatically inserted in the last whitespace.\n     * Disable by setting value to 0\n     * @private\n     */\n    protected _maxWidth: number;\n\n    /**\n     * The max line height. This is useful when trying to use the total height of the Text,\n     * ie: when trying to vertically align. (Internally used)\n     * @private\n     */\n    protected _maxLineHeight: number;\n\n    /**\n     * Letter spacing. This is useful for setting the space between characters.\n     * @private\n     */\n    protected _letterSpacing: number;\n\n    /**\n     * Text anchor.\n     * @readonly\n     * @private\n     */\n    protected _anchor: ObservablePoint;\n\n    /**\n     * Private tracker for the current font.\n     * @private\n     */\n    protected _font?: BitmapFont;\n\n    /**\n     * Private tracker for the current font name.\n     * @private\n     */\n    protected _fontName: string;\n\n    /**\n     * Private tracker for the current font size.\n     * @private\n     */\n    protected _fontSize?: number;\n\n    /**\n     * Private tracker for the current text align.\n     * @type {string}\n     * @private\n     */\n    protected _align: TextStyleAlign;\n\n    /** Collection of page mesh data. */\n    protected _activePagesMeshData: PageMeshData[];\n\n    /**\n     * Private tracker for the current tint.\n     * @private\n     */\n    protected _tint = 0xFFFFFF;\n\n    /**\n     * If true PixiJS will Math.floor() x/y values when rendering.\n     * @default PIXI.settings.ROUND_PIXELS\n     */\n    protected _roundPixels: boolean;\n\n    /** Cached char texture is destroyed when BitmapText is destroyed. */\n    private _textureCache: Record<number, Texture>;\n\n    /**\n     * @param text - A string that you would like the text to display.\n     * @param style - The style parameters.\n     * @param {string} style.fontName - The installed BitmapFont name.\n     * @param {number} [style.fontSize] - The size of the font in pixels, e.g. 24. If undefined,\n     *.     this will default to the BitmapFont size.\n     * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center', 'right' or 'justify'),\n     *      does not affect single line text.\n     * @param {number} [style.tint=0xFFFFFF] - The tint color.\n     * @param {number} [style.letterSpacing=0] - The amount of spacing between letters.\n     * @param {number} [style.maxWidth=0] - The max width of the text before line wrapping.\n     */\n    constructor(text: string, style: Partial<IBitmapTextStyle> = {})\n    {\n        super();\n\n        // Apply the defaults\n        const { align, tint, maxWidth, letterSpacing, fontName, fontSize } = Object.assign(\n            {}, BitmapText.styleDefaults, style);\n\n        if (!BitmapFont.available[fontName])\n        {\n            throw new Error(`Missing BitmapFont \"${fontName}\"`);\n        }\n\n        this._activePagesMeshData = [];\n        this._textWidth = 0;\n        this._textHeight = 0;\n        this._align = align;\n        this._tint = tint;\n        this._font = undefined;\n        this._fontName = fontName;\n        this._fontSize = fontSize;\n        this.text = text;\n        this._maxWidth = maxWidth;\n        this._maxLineHeight = 0;\n        this._letterSpacing = letterSpacing;\n        this._anchor = new ObservablePoint((): void => { this.dirty = true; }, this, 0, 0);\n        this._roundPixels = settings.ROUND_PIXELS;\n        this.dirty = true;\n        this._resolution = settings.RESOLUTION;\n        this._autoResolution = true;\n        this._textureCache = {};\n    }\n\n    /** Renders text and updates it when needed. This should only be called if the BitmapFont is regenerated. */\n    public updateText(): void\n    {\n        const data = BitmapFont.available[this._fontName];\n        const fontSize = this.fontSize;\n        const scale = fontSize / data.size;\n        const pos = new Point();\n        const chars: CharRenderData[] = [];\n        const lineWidths = [];\n        const lineSpaces = [];\n        const text = this._text.replace(/(?:\\r\\n|\\r)/g, '\\n') || ' ';\n        const charsInput = splitTextToCharacters(text);\n        const maxWidth = this._maxWidth * data.size / fontSize;\n        const pageMeshDataPool = data.distanceFieldType === 'none'\n            ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;\n\n        let prevCharCode = null;\n        let lastLineWidth = 0;\n        let maxLineWidth = 0;\n        let line = 0;\n        let lastBreakPos = -1;\n        let lastBreakWidth = 0;\n        let spacesRemoved = 0;\n        let maxLineHeight = 0;\n        let spaceCount = 0;\n\n        for (let i = 0; i < charsInput.length; i++)\n        {\n            const char = charsInput[i];\n            const charCode = extractCharCode(char);\n\n            if ((/(?:\\s)/).test(char))\n            {\n                lastBreakPos = i;\n                lastBreakWidth = lastLineWidth;\n                spaceCount++;\n            }\n\n            if (char === '\\r' || char === '\\n')\n            {\n                lineWidths.push(lastLineWidth);\n                lineSpaces.push(-1);\n                maxLineWidth = Math.max(maxLineWidth, lastLineWidth);\n                ++line;\n                ++spacesRemoved;\n\n                pos.x = 0;\n                pos.y += data.lineHeight;\n                prevCharCode = null;\n                spaceCount = 0;\n                continue;\n            }\n\n            const charData = data.chars[charCode];\n\n            if (!charData)\n            {\n                continue;\n            }\n\n            if (prevCharCode && charData.kerning[prevCharCode])\n            {\n                pos.x += charData.kerning[prevCharCode];\n            }\n\n            const charRenderData: CharRenderData = charRenderDataPool.pop() || {\n                texture: Texture.EMPTY,\n                line: 0,\n                charCode: 0,\n                prevSpaces: 0,\n                position: new Point(),\n            };\n\n            charRenderData.texture = charData.texture;\n            charRenderData.line = line;\n            charRenderData.charCode = charCode;\n            charRenderData.position.x = pos.x + charData.xOffset + (this._letterSpacing / 2);\n            charRenderData.position.y = pos.y + charData.yOffset;\n            charRenderData.prevSpaces = spaceCount;\n\n            chars.push(charRenderData);\n\n            lastLineWidth = charRenderData.position.x\n                + Math.max(charData.xAdvance - charData.xOffset, charData.texture.orig.width);\n            pos.x += charData.xAdvance + this._letterSpacing;\n            maxLineHeight = Math.max(maxLineHeight, (charData.yOffset + charData.texture.height));\n            prevCharCode = charCode;\n\n            if (lastBreakPos !== -1 && maxWidth > 0 && pos.x > maxWidth)\n            {\n                ++spacesRemoved;\n                removeItems(chars, 1 + lastBreakPos - spacesRemoved, 1 + i - lastBreakPos);\n                i = lastBreakPos;\n                lastBreakPos = -1;\n\n                lineWidths.push(lastBreakWidth);\n                lineSpaces.push(chars.length > 0 ? chars[chars.length - 1].prevSpaces : 0);\n                maxLineWidth = Math.max(maxLineWidth, lastBreakWidth);\n                line++;\n\n                pos.x = 0;\n                pos.y += data.lineHeight;\n                prevCharCode = null;\n                spaceCount = 0;\n            }\n        }\n\n        const lastChar = charsInput[charsInput.length - 1];\n\n        if (lastChar !== '\\r' && lastChar !== '\\n')\n        {\n            if ((/(?:\\s)/).test(lastChar))\n            {\n                lastLineWidth = lastBreakWidth;\n            }\n\n            lineWidths.push(lastLineWidth);\n            maxLineWidth = Math.max(maxLineWidth, lastLineWidth);\n            lineSpaces.push(-1);\n        }\n\n        const lineAlignOffsets = [];\n\n        for (let i = 0; i <= line; i++)\n        {\n            let alignOffset = 0;\n\n            if (this._align === 'right')\n            {\n                alignOffset = maxLineWidth - lineWidths[i];\n            }\n            else if (this._align === 'center')\n            {\n                alignOffset = (maxLineWidth - lineWidths[i]) / 2;\n            }\n            else if (this._align === 'justify')\n            {\n                alignOffset = lineSpaces[i] < 0 ? 0 : (maxLineWidth - lineWidths[i]) / lineSpaces[i];\n            }\n\n            lineAlignOffsets.push(alignOffset);\n        }\n\n        const lenChars = chars.length;\n\n        const pagesMeshData: Record<number, PageMeshData> = {};\n\n        const newPagesMeshData: PageMeshData[] = [];\n\n        const activePagesMeshData = this._activePagesMeshData;\n\n        pageMeshDataPool.push(...activePagesMeshData);\n\n        for (let i = 0; i < lenChars; i++)\n        {\n            const texture = chars[i].texture;\n            const baseTextureUid = texture.baseTexture.uid;\n\n            if (!pagesMeshData[baseTextureUid])\n            {\n                let pageMeshData = pageMeshDataPool.pop();\n\n                if (!pageMeshData)\n                {\n                    const geometry = new MeshGeometry();\n                    let material: MeshMaterial;\n                    let meshBlendMode: BLEND_MODES;\n\n                    if (data.distanceFieldType === 'none')\n                    {\n                        material = new MeshMaterial(Texture.EMPTY);\n                        meshBlendMode = BLEND_MODES.NORMAL;\n                    }\n                    else\n                    {\n                        material = new MeshMaterial(Texture.EMPTY,\n                            { program: Program.from(msdfVert, msdfFrag), uniforms: { uFWidth: 0 } });\n                        meshBlendMode = BLEND_MODES.NORMAL_NPM;\n                    }\n\n                    const mesh = new Mesh(geometry, material);\n\n                    mesh.blendMode = meshBlendMode;\n\n                    pageMeshData = {\n                        index: 0,\n                        indexCount: 0,\n                        vertexCount: 0,\n                        uvsCount: 0,\n                        total: 0,\n                        mesh,\n                        vertices: null,\n                        uvs: null,\n                        indices: null,\n                    };\n                }\n\n                // reset data..\n                pageMeshData.index = 0;\n                pageMeshData.indexCount = 0;\n                pageMeshData.vertexCount = 0;\n                pageMeshData.uvsCount = 0;\n                pageMeshData.total = 0;\n\n                // TODO need to get page texture here somehow..\n                const { _textureCache } = this;\n\n                _textureCache[baseTextureUid] = _textureCache[baseTextureUid] || new Texture(texture.baseTexture);\n                pageMeshData.mesh.texture = _textureCache[baseTextureUid];\n\n                pageMeshData.mesh.tint = this._tint;\n\n                newPagesMeshData.push(pageMeshData);\n\n                pagesMeshData[baseTextureUid] = pageMeshData;\n            }\n\n            pagesMeshData[baseTextureUid].total++;\n        }\n\n        // lets find any previously active pageMeshDatas that are no longer required for\n        // the updated text (if any), removed and return them to the pool.\n        for (let i = 0; i < activePagesMeshData.length; i++)\n        {\n            if (newPagesMeshData.indexOf(activePagesMeshData[i]) === -1)\n            {\n                this.removeChild(activePagesMeshData[i].mesh);\n            }\n        }\n\n        // next lets add any new meshes, that have not yet been added to this BitmapText\n        // we only add if its not already a child of this BitmapObject\n        for (let i = 0; i < newPagesMeshData.length; i++)\n        {\n            if (newPagesMeshData[i].mesh.parent !== this)\n            {\n                this.addChild(newPagesMeshData[i].mesh);\n            }\n        }\n\n        // active page mesh datas are set to be the new pages added.\n        this._activePagesMeshData = newPagesMeshData;\n\n        for (const i in pagesMeshData)\n        {\n            const pageMeshData = pagesMeshData[i];\n            const total = pageMeshData.total;\n\n            // lets only allocate new buffers if we can fit the new text in the current ones..\n            // unless that is, we will be batching. Currently batching dose not respect the size property of mesh\n            if (!(pageMeshData.indices?.length > 6 * total) || pageMeshData.vertices.length < Mesh.BATCHABLE_SIZE * 2)\n            {\n                pageMeshData.vertices = new Float32Array(4 * 2 * total);\n                pageMeshData.uvs = new Float32Array(4 * 2 * total);\n                pageMeshData.indices = new Uint16Array(6 * total);\n            }\n            else\n            {\n                const total = pageMeshData.total;\n                const vertices = pageMeshData.vertices;\n\n                // Clear the garbage at the end of the vertices buffer. This will prevent the bounds miscalculation.\n                for (let i = total * 4 * 2; i < vertices.length; i++)\n                {\n                    vertices[i] = 0;\n                }\n            }\n\n            // as a buffer maybe bigger than the current word, we set the size of the meshMaterial\n            // to match the number of letters needed\n            pageMeshData.mesh.size = 6 * total;\n        }\n\n        for (let i = 0; i < lenChars; i++)\n        {\n            const char = chars[i];\n            let offset = char.position.x + (lineAlignOffsets[char.line] * (this._align === 'justify' ? char.prevSpaces : 1));\n\n            if (this._roundPixels)\n            {\n                offset = Math.round(offset);\n            }\n\n            const xPos = offset * scale;\n            const yPos = char.position.y * scale;\n            const texture = char.texture;\n\n            const pageMesh = pagesMeshData[texture.baseTexture.uid];\n\n            const textureFrame = texture.frame;\n            const textureUvs = texture._uvs;\n\n            const index = pageMesh.index++;\n\n            pageMesh.indices[(index * 6) + 0] = 0 + (index * 4);\n            pageMesh.indices[(index * 6) + 1] = 1 + (index * 4);\n            pageMesh.indices[(index * 6) + 2] = 2 + (index * 4);\n            pageMesh.indices[(index * 6) + 3] = 0 + (index * 4);\n            pageMesh.indices[(index * 6) + 4] = 2 + (index * 4);\n            pageMesh.indices[(index * 6) + 5] = 3 + (index * 4);\n\n            pageMesh.vertices[(index * 8) + 0] = xPos;\n            pageMesh.vertices[(index * 8) + 1] = yPos;\n\n            pageMesh.vertices[(index * 8) + 2] = xPos + (textureFrame.width * scale);\n            pageMesh.vertices[(index * 8) + 3] = yPos;\n\n            pageMesh.vertices[(index * 8) + 4] = xPos + (textureFrame.width * scale);\n            pageMesh.vertices[(index * 8) + 5] = yPos + (textureFrame.height * scale);\n\n            pageMesh.vertices[(index * 8) + 6] = xPos;\n            pageMesh.vertices[(index * 8) + 7] = yPos + (textureFrame.height * scale);\n\n            pageMesh.uvs[(index * 8) + 0] = textureUvs.x0;\n            pageMesh.uvs[(index * 8) + 1] = textureUvs.y0;\n\n            pageMesh.uvs[(index * 8) + 2] = textureUvs.x1;\n            pageMesh.uvs[(index * 8) + 3] = textureUvs.y1;\n\n            pageMesh.uvs[(index * 8) + 4] = textureUvs.x2;\n            pageMesh.uvs[(index * 8) + 5] = textureUvs.y2;\n\n            pageMesh.uvs[(index * 8) + 6] = textureUvs.x3;\n            pageMesh.uvs[(index * 8) + 7] = textureUvs.y3;\n        }\n\n        this._textWidth = maxLineWidth * scale;\n        this._textHeight = (pos.y + data.lineHeight) * scale;\n\n        for (const i in pagesMeshData)\n        {\n            const pageMeshData = pagesMeshData[i];\n\n            // apply anchor\n            if (this.anchor.x !== 0 || this.anchor.y !== 0)\n            {\n                let vertexCount = 0;\n\n                const anchorOffsetX = this._textWidth * this.anchor.x;\n                const anchorOffsetY = this._textHeight * this.anchor.y;\n\n                for (let i = 0; i < pageMeshData.total; i++)\n                {\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetX;\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetY;\n\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetX;\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetY;\n\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetX;\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetY;\n\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetX;\n                    pageMeshData.vertices[vertexCount++] -= anchorOffsetY;\n                }\n            }\n\n            this._maxLineHeight = maxLineHeight * scale;\n\n            const vertexBuffer = pageMeshData.mesh.geometry.getBuffer('aVertexPosition');\n            const textureBuffer = pageMeshData.mesh.geometry.getBuffer('aTextureCoord');\n            const indexBuffer = pageMeshData.mesh.geometry.getIndex();\n\n            vertexBuffer.data = pageMeshData.vertices;\n            textureBuffer.data = pageMeshData.uvs;\n            indexBuffer.data = pageMeshData.indices;\n\n            vertexBuffer.update();\n            textureBuffer.update();\n            indexBuffer.update();\n        }\n\n        for (let i = 0; i < chars.length; i++)\n        {\n            charRenderDataPool.push(chars[i]);\n        }\n\n        this._font = data;\n        this.dirty = false;\n    }\n\n    updateTransform(): void\n    {\n        this.validate();\n        this.containerUpdateTransform();\n    }\n\n    _render(renderer: Renderer): void\n    {\n        if (this._autoResolution && this._resolution !== renderer.resolution)\n        {\n            this._resolution = renderer.resolution;\n            this.dirty = true;\n        }\n\n        // Update the uniform\n        const { distanceFieldRange, distanceFieldType, size } = BitmapFont.available[this._fontName];\n\n        if (distanceFieldType !== 'none')\n        {\n            // Inject the shader code with the correct value\n            const { a, b, c, d } = this.worldTransform;\n\n            const dx = Math.sqrt((a * a) + (b * b));\n            const dy = Math.sqrt((c * c) + (d * d));\n            const worldScale = (Math.abs(dx) + Math.abs(dy)) / 2;\n\n            const fontScale = this.fontSize / size;\n\n            for (const mesh of this._activePagesMeshData)\n            {\n                mesh.mesh.shader.uniforms.uFWidth = worldScale * distanceFieldRange * fontScale * this._resolution;\n            }\n        }\n\n        super._render(renderer);\n    }\n\n    /**\n     * Validates text before calling parent's getLocalBounds\n     * @returns - The rectangular bounding area\n     */\n    public getLocalBounds(): Rectangle\n    {\n        this.validate();\n\n        return super.getLocalBounds();\n    }\n\n    /**\n     * Updates text when needed\n     * @private\n     */\n    protected validate(): void\n    {\n        const font = BitmapFont.available[this._fontName];\n\n        if (!font)\n        {\n            throw new Error(`Missing BitmapFont \"${this._fontName}\"`);\n        }\n        if (this._font !== font)\n        {\n            this.dirty = true;\n        }\n\n        if (this.dirty)\n        {\n            this.updateText();\n        }\n    }\n\n    /**\n     * The tint of the BitmapText object.\n     * @default 0xffffff\n     */\n    public get tint(): number\n    {\n        return this._tint;\n    }\n\n    public set tint(value: number)\n    {\n        if (this._tint === value) return;\n\n        this._tint = value;\n\n        for (let i = 0; i < this._activePagesMeshData.length; i++)\n        {\n            this._activePagesMeshData[i].mesh.tint = value;\n        }\n    }\n\n    /**\n     * The alignment of the BitmapText object.\n     * @member {string}\n     * @default 'left'\n     */\n    public get align(): TextStyleAlign\n    {\n        return this._align;\n    }\n\n    public set align(value: TextStyleAlign)\n    {\n        if (this._align !== value)\n        {\n            this._align = value;\n            this.dirty = true;\n        }\n    }\n\n    /** The name of the BitmapFont. */\n    public get fontName(): string\n    {\n        return this._fontName;\n    }\n\n    public set fontName(value: string)\n    {\n        if (!BitmapFont.available[value])\n        {\n            throw new Error(`Missing BitmapFont \"${value}\"`);\n        }\n\n        if (this._fontName !== value)\n        {\n            this._fontName = value;\n            this.dirty = true;\n        }\n    }\n\n    /** The size of the font to display. */\n    public get fontSize(): number\n    {\n        return this._fontSize ?? BitmapFont.available[this._fontName].size;\n    }\n\n    public set fontSize(value: number | undefined)\n    {\n        if (this._fontSize !== value)\n        {\n            this._fontSize = value;\n            this.dirty = true;\n        }\n    }\n\n    /**\n     * The anchor sets the origin point of the text.\n     *\n     * The default is `(0,0)`, this means the text's origin is the top left.\n     *\n     * Setting the anchor to `(0.5,0.5)` means the text's origin is centered.\n     *\n     * Setting the anchor to `(1,1)` would mean the text's origin point will be the bottom right corner.\n     */\n    public get anchor(): ObservablePoint\n    {\n        return this._anchor;\n    }\n\n    public set anchor(value: ObservablePoint)\n    {\n        if (typeof value === 'number')\n        {\n            this._anchor.set(value);\n        }\n        else\n        {\n            this._anchor.copyFrom(value);\n        }\n    }\n\n    /** The text of the BitmapText object. */\n    public get text(): string\n    {\n        return this._text;\n    }\n\n    public set text(text: string)\n    {\n        text = String(text === null || text === undefined ? '' : text);\n\n        if (this._text === text)\n        {\n            return;\n        }\n        this._text = text;\n        this.dirty = true;\n    }\n\n    /**\n     * The max width of this bitmap text in pixels. If the text provided is longer than the\n     * value provided, line breaks will be automatically inserted in the last whitespace.\n     * Disable by setting the value to 0.\n     */\n    public get maxWidth(): number\n    {\n        return this._maxWidth;\n    }\n\n    public set maxWidth(value: number)\n    {\n        if (this._maxWidth === value)\n        {\n            return;\n        }\n        this._maxWidth = value;\n        this.dirty = true;\n    }\n\n    /**\n     * The max line height. This is useful when trying to use the total height of the Text,\n     * i.e. when trying to vertically align.\n     * @readonly\n     */\n    public get maxLineHeight(): number\n    {\n        this.validate();\n\n        return this._maxLineHeight;\n    }\n\n    /**\n     * The width of the overall text, different from fontSize,\n     * which is defined in the style object.\n     * @readonly\n     */\n    public get textWidth(): number\n    {\n        this.validate();\n\n        return this._textWidth;\n    }\n\n    /** Additional space between characters. */\n    public get letterSpacing(): number\n    {\n        return this._letterSpacing;\n    }\n\n    public set letterSpacing(value: number)\n    {\n        if (this._letterSpacing !== value)\n        {\n            this._letterSpacing = value;\n            this.dirty = true;\n        }\n    }\n\n    /**\n     * If true PixiJS will Math.floor() x/y values when rendering, stopping pixel interpolation.\n     * Advantages can include sharper image quality (like text) and faster rendering on canvas.\n     * The main disadvantage is movement of objects may appear less smooth.\n     * To set the global default, change {@link PIXI.settings.ROUND_PIXELS}\n     * @default PIXI.settings.ROUND_PIXELS\n     */\n    public get roundPixels(): boolean\n    {\n        return this._roundPixels;\n    }\n\n    public set roundPixels(value: boolean)\n    {\n        if (value !== this._roundPixels)\n        {\n            this._roundPixels = value;\n            this.dirty = true;\n        }\n    }\n\n    /**\n     * The height of the overall text, different from fontSize,\n     * which is defined in the style object.\n     * @readonly\n     */\n    public get textHeight(): number\n    {\n        this.validate();\n\n        return this._textHeight;\n    }\n\n    /**\n     * The resolution / device pixel ratio of the canvas.\n     *\n     * This is set to automatically match the renderer resolution by default, but can be overridden by setting manually.\n     * @default 1\n     */\n    get resolution(): number\n    {\n        return this._resolution;\n    }\n\n    set resolution(value: number)\n    {\n        this._autoResolution = false;\n\n        if (this._resolution === value)\n        {\n            return;\n        }\n\n        this._resolution = value;\n        this.dirty = true;\n    }\n\n    destroy(options?: boolean | IDestroyOptions): void\n    {\n        const { _textureCache } = this;\n        const data = BitmapFont.available[this._fontName];\n        const pageMeshDataPool = data.distanceFieldType === 'none'\n            ? pageMeshDataDefaultPageMeshData : pageMeshDataMSDFPageMeshData;\n\n        pageMeshDataPool.push(...this._activePagesMeshData);\n        for (const pageMeshData of this._activePagesMeshData)\n        {\n            this.removeChild(pageMeshData.mesh);\n        }\n        this._activePagesMeshData = [];\n\n        // Release references to any cached textures in page pool\n        pageMeshDataPool\n            .filter((page) => _textureCache[page.mesh.texture.baseTexture.uid])\n            .forEach((page) =>\n            {\n                page.mesh.texture = Texture.EMPTY;\n            });\n\n        for (const id in _textureCache)\n        {\n            const texture = _textureCache[id];\n\n            texture.destroy();\n            delete _textureCache[id];\n        }\n\n        this._font = null;\n        this._textureCache = null;\n\n        super.destroy(options);\n    }\n}\n","import { LoaderResource } from '@pixi/loaders';\nimport { autoDetectFormat } from './formats';\nimport { BitmapFont } from './BitmapFont';\n\nimport type { Loader } from '@pixi/loaders';\nimport type { Dict } from '@pixi/utils';\nimport type { ExtensionMetadata, Texture } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\n\n/**\n * {@link PIXI.Loader Loader} middleware for loading\n * bitmap-based fonts suitable for using with {@link PIXI.BitmapText}.\n * @memberof PIXI\n */\nexport class BitmapFontLoader\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Loader;\n\n    /**\n     * Called when the plugin is installed.\n     * @see PIXI.extensions.add\n     */\n    public static add(): void\n    {\n        LoaderResource.setExtensionXhrType('fnt', LoaderResource.XHR_RESPONSE_TYPE.TEXT);\n    }\n\n    /**\n     * Called after a resource is loaded.\n     * @see PIXI.Loader.loaderMiddleware\n     * @param this\n     * @param {PIXI.LoaderResource} resource\n     * @param {Function} next\n     */\n    static use(this: Loader, resource: LoaderResource, next: (...args: any[]) => void): void\n    {\n        const format = autoDetectFormat(resource.data);\n\n        // Resource was not recognised as any of the expected font data format\n        if (!format)\n        {\n            next();\n\n            return;\n        }\n\n        const baseUrl = BitmapFontLoader.getBaseUrl(this, resource);\n        const data = format.parse(resource.data);\n        const textures: Dict<Texture> = {};\n\n        // Handle completed, when the number of textures\n        // load is the same number as references in the fnt file\n        const completed = (page: LoaderResource): void =>\n        {\n            textures[page.metadata.pageFile] = page.texture;\n\n            if (Object.keys(textures).length === data.page.length)\n            {\n                resource.bitmapFont = BitmapFont.install(data, textures, true);\n                next();\n            }\n        };\n\n        for (let i = 0; i < data.page.length; ++i)\n        {\n            const pageFile = data.page[i].file;\n            const url = baseUrl + pageFile;\n            let exists = false;\n\n            // incase the image is loaded outside\n            // using the same loader, resource will be available\n            for (const name in this.resources)\n            {\n                const bitmapResource: LoaderResource = this.resources[name];\n\n                if (bitmapResource.url === url)\n                {\n                    bitmapResource.metadata.pageFile = pageFile;\n                    if (bitmapResource.texture)\n                    {\n                        completed(bitmapResource);\n                    }\n                    else\n                    {\n                        bitmapResource.onAfterMiddleware.add(completed);\n                    }\n                    exists = true;\n                    break;\n                }\n            }\n\n            // texture is not loaded, we'll attempt to add\n            // it to the load and add the texture to the list\n            if (!exists)\n            {\n                // Standard loading options for images\n                const options = {\n                    crossOrigin: resource.crossOrigin,\n                    loadType: LoaderResource.LOAD_TYPE.IMAGE,\n                    metadata: Object.assign(\n                        { pageFile },\n                        resource.metadata.imageMetadata\n                    ),\n                    parentResource: resource,\n                };\n\n                this.add(url, options, completed);\n            }\n        }\n    }\n\n    /**\n     * Get folder path from a resource.\n     * @param loader\n     * @param resource\n     */\n    private static getBaseUrl(loader: Loader, resource: LoaderResource): string\n    {\n        let resUrl = !resource.isDataUrl ? BitmapFontLoader.dirname(resource.url) : '';\n\n        if (resource.isDataUrl)\n        {\n            if (resUrl === '.')\n            {\n                resUrl = '';\n            }\n\n            if (loader.baseUrl && resUrl)\n            {\n                // if baseurl has a trailing slash then add one to resUrl so the replace works below\n                if (loader.baseUrl.charAt(loader.baseUrl.length - 1) === '/')\n                {\n                    resUrl += '/';\n                }\n            }\n        }\n\n        // remove baseUrl from resUrl\n        resUrl = resUrl.replace(loader.baseUrl, '');\n\n        // if there is an resUrl now, it needs a trailing slash. Ensure that it does if the string isn't empty.\n        if (resUrl && resUrl.charAt(resUrl.length - 1) !== '/')\n        {\n            resUrl += '/';\n        }\n\n        return resUrl;\n    }\n\n    /**\n     * Replacement for NodeJS's path.dirname\n     * @param {string} url - Path to get directory for\n     */\n    private static dirname(url: string): string\n    {\n        const dir = url\n            .replace(/\\\\/g, '/') // convert windows notation to UNIX notation, URL-safe because it's a forbidden character\n            .replace(/\\/$/, '') // replace trailing slash\n            .replace(/\\/[^\\/]*$/, ''); // remove everything after the last\n\n        // File request is relative, use current directory\n        if (dir === url)\n        {\n            return '.';\n        }\n        // Started with a slash\n        else if (dir === '')\n        {\n            return '/';\n        }\n\n        return dir;\n    }\n}\n","import { Filter, defaultVertex } from '@pixi/core';\nimport fragment from './alpha.frag';\n\n/**\n * Simplest filter - applies alpha.\n *\n * Use this instead of Container's alpha property to avoid visual layering of individual elements.\n * AlphaFilter applies alpha evenly across the entire display object and any opaque elements it contains.\n * If elements are not opaque, they will blend with each other anyway.\n *\n * Very handy if you want to use common features of all filters:\n *\n * 1. Assign a blendMode to this filter, blend all elements inside display object with background.\n *\n * 2. To use clipping in display coordinates, assign a filterArea to the same container that has this filter.\n * @memberof PIXI.filters\n */\nexport class AlphaFilter extends Filter\n{\n    /**\n     * @param alpha - Amount of alpha from 0 to 1, where 0 is transparent\n     */\n    constructor(alpha = 1.0)\n    {\n        super(defaultVertex, fragment, { uAlpha: 1 });\n\n        this.alpha = alpha;\n    }\n\n    /**\n     * Coefficient for alpha multiplication\n     * @default 1\n     */\n    get alpha(): number\n    {\n        return this.uniforms.uAlpha;\n    }\n\n    set alpha(value: number)\n    {\n        this.uniforms.uAlpha = value;\n    }\n}\n","const vertTemplate = `\n    attribute vec2 aVertexPosition;\n\n    uniform mat3 projectionMatrix;\n\n    uniform float strength;\n\n    varying vec2 vBlurTexCoords[%size%];\n\n    uniform vec4 inputSize;\n    uniform vec4 outputFrame;\n\n    vec4 filterVertexPosition( void )\n    {\n        vec2 position = aVertexPosition * max(outputFrame.zw, vec2(0.)) + outputFrame.xy;\n\n        return vec4((projectionMatrix * vec3(position, 1.0)).xy, 0.0, 1.0);\n    }\n\n    vec2 filterTextureCoord( void )\n    {\n        return aVertexPosition * (outputFrame.zw * inputSize.zw);\n    }\n\n    void main(void)\n    {\n        gl_Position = filterVertexPosition();\n\n        vec2 textureCoord = filterTextureCoord();\n        %blur%\n    }`;\n\nexport function generateBlurVertSource(kernelSize: number, x: boolean): string\n{\n    const halfLength = Math.ceil(kernelSize / 2);\n\n    let vertSource = vertTemplate;\n\n    let blurLoop = '';\n    let template;\n\n    if (x)\n    {\n        template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(%sampleIndex% * strength, 0.0);';\n    }\n    else\n    {\n        template = 'vBlurTexCoords[%index%] =  textureCoord + vec2(0.0, %sampleIndex% * strength);';\n    }\n\n    for (let i = 0; i < kernelSize; i++)\n    {\n        let blur = template.replace('%index%', i.toString());\n\n        blur = blur.replace('%sampleIndex%', `${i - (halfLength - 1)}.0`);\n\n        blurLoop += blur;\n        blurLoop += '\\n';\n    }\n\n    vertSource = vertSource.replace('%blur%', blurLoop);\n    vertSource = vertSource.replace('%size%', kernelSize.toString());\n\n    return vertSource;\n}\n","interface IGAUSSIAN_VALUES\n{\n    [x: number]: number[];\n}\nconst GAUSSIAN_VALUES: IGAUSSIAN_VALUES = {\n    5: [0.153388, 0.221461, 0.250301],\n    7: [0.071303, 0.131514, 0.189879, 0.214607],\n    9: [0.028532, 0.067234, 0.124009, 0.179044, 0.20236],\n    11: [0.0093, 0.028002, 0.065984, 0.121703, 0.175713, 0.198596],\n    13: [0.002406, 0.009255, 0.027867, 0.065666, 0.121117, 0.174868, 0.197641],\n    15: [0.000489, 0.002403, 0.009246, 0.02784, 0.065602, 0.120999, 0.174697, 0.197448],\n};\n\nconst fragTemplate = [\n    'varying vec2 vBlurTexCoords[%size%];',\n    'uniform sampler2D uSampler;',\n\n    'void main(void)',\n    '{',\n    '    gl_FragColor = vec4(0.0);',\n    '    %blur%',\n    '}',\n\n].join('\\n');\n\nexport function generateBlurFragSource(kernelSize: number): string\n{\n    const kernel = GAUSSIAN_VALUES[kernelSize];\n    const halfLength = kernel.length;\n\n    let fragSource = fragTemplate;\n\n    let blurLoop = '';\n    const template = 'gl_FragColor += texture2D(uSampler, vBlurTexCoords[%index%]) * %value%;';\n    let value: number;\n\n    for (let i = 0; i < kernelSize; i++)\n    {\n        let blur = template.replace('%index%', i.toString());\n\n        value = i;\n\n        if (i >= halfLength)\n        {\n            value = kernelSize - i - 1;\n        }\n\n        blur = blur.replace('%value%', kernel[value].toString());\n\n        blurLoop += blur;\n        blurLoop += '\\n';\n    }\n\n    fragSource = fragSource.replace('%blur%', blurLoop);\n    fragSource = fragSource.replace('%size%', kernelSize.toString());\n\n    return fragSource;\n}\n","import { Filter } from '@pixi/core';\nimport { settings } from '@pixi/settings';\nimport { generateBlurVertSource } from './generateBlurVertSource';\nimport { generateBlurFragSource } from './generateBlurFragSource';\nimport { CLEAR_MODES } from '@pixi/constants';\n\nimport type { FilterSystem, RenderTexture } from '@pixi/core';\n\n/**\n * The BlurFilterPass applies a horizontal or vertical Gaussian blur to an object.\n * @memberof PIXI.filters\n */\nexport class BlurFilterPass extends Filter\n{\n    public horizontal: boolean;\n    public strength: number;\n    public passes: number;\n\n    private _quality: number;\n\n    /**\n     * @param horizontal - Do pass along the x-axis (`true`) or y-axis (`false`).\n     * @param strength - The strength of the blur filter.\n     * @param quality - The quality of the blur filter.\n     * @param resolution - The resolution of the blur filter.\n     * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.\n     */\n    constructor(horizontal: boolean, strength = 8, quality = 4, resolution = settings.FILTER_RESOLUTION, kernelSize = 5)\n    {\n        const vertSrc = generateBlurVertSource(kernelSize, horizontal);\n        const fragSrc = generateBlurFragSource(kernelSize);\n\n        super(\n            // vertex shader\n            vertSrc,\n            // fragment shader\n            fragSrc\n        );\n\n        this.horizontal = horizontal;\n\n        this.resolution = resolution;\n\n        this._quality = 0;\n\n        this.quality = quality;\n\n        this.blur = strength;\n    }\n\n    /**\n     * Applies the filter.\n     * @param filterManager - The manager.\n     * @param input - The input target.\n     * @param output - The output target.\n     * @param clearMode - How to clear\n     */\n    public apply(\n        filterManager: FilterSystem, input: RenderTexture, output: RenderTexture, clearMode: CLEAR_MODES\n    ): void\n    {\n        if (output)\n        {\n            if (this.horizontal)\n            {\n                this.uniforms.strength = (1 / output.width) * (output.width / input.width);\n            }\n            else\n            {\n                this.uniforms.strength = (1 / output.height) * (output.height / input.height);\n            }\n        }\n        else\n        {\n            if (this.horizontal) // eslint-disable-line\n            {\n                this.uniforms.strength = (1 / filterManager.renderer.width) * (filterManager.renderer.width / input.width);\n            }\n            else\n            {\n                this.uniforms.strength = (1 / filterManager.renderer.height) * (filterManager.renderer.height / input.height); // eslint-disable-line\n            }\n        }\n\n        // screen space!\n        this.uniforms.strength *= this.strength;\n        this.uniforms.strength /= this.passes;\n\n        if (this.passes === 1)\n        {\n            filterManager.applyFilter(this, input, output, clearMode);\n        }\n        else\n        {\n            const renderTarget = filterManager.getFilterTexture();\n            const renderer = filterManager.renderer;\n\n            let flip = input;\n            let flop = renderTarget;\n\n            this.state.blend = false;\n            filterManager.applyFilter(this, flip, flop, CLEAR_MODES.CLEAR);\n\n            for (let i = 1; i < this.passes - 1; i++)\n            {\n                filterManager.bindAndClear(flip, CLEAR_MODES.BLIT);\n\n                this.uniforms.uSampler = flop;\n\n                const temp = flop;\n\n                flop = flip;\n                flip = temp;\n\n                renderer.shader.bind(this);\n                renderer.geometry.draw(5);\n            }\n\n            this.state.blend = true;\n            filterManager.applyFilter(this, flop, output, clearMode);\n            filterManager.returnFilterTexture(renderTarget);\n        }\n    }\n    /**\n     * Sets the strength of both the blur.\n     * @default 16\n     */\n    get blur(): number\n    {\n        return this.strength;\n    }\n\n    set blur(value: number)\n    {\n        this.padding = 1 + (Math.abs(value) * 2);\n        this.strength = value;\n    }\n\n    /**\n     * Sets the quality of the blur by modifying the number of passes. More passes means higher\n     * quality bluring but the lower the performance.\n     * @default 4\n     */\n    get quality(): number\n    {\n        return this._quality;\n    }\n\n    set quality(value: number)\n    {\n        this._quality = value;\n        this.passes = value;\n    }\n}\n","import { Filter } from '@pixi/core';\nimport { settings } from '@pixi/settings';\nimport { BlurFilterPass } from './BlurFilterPass';\nimport { CLEAR_MODES } from '@pixi/constants';\n\nimport type { FilterSystem, RenderTexture } from '@pixi/core';\nimport type { BLEND_MODES } from '@pixi/constants';\n\n/**\n * The BlurFilter applies a Gaussian blur to an object.\n *\n * The strength of the blur can be set for the x-axis and y-axis separately.\n * @memberof PIXI.filters\n */\nexport class BlurFilter extends Filter\n{\n    public blurXFilter: BlurFilterPass;\n    public blurYFilter: BlurFilterPass;\n\n    private _repeatEdgePixels: boolean;\n\n    /**\n     * @param strength - The strength of the blur filter.\n     * @param quality - The quality of the blur filter.\n     * @param [resolution=PIXI.settings.FILTER_RESOLUTION] - The resolution of the blur filter.\n     * @param kernelSize - The kernelSize of the blur filter.Options: 5, 7, 9, 11, 13, 15.\n     */\n    constructor(strength = 8, quality = 4, resolution = settings.FILTER_RESOLUTION, kernelSize = 5)\n    {\n        super();\n\n        this.blurXFilter = new BlurFilterPass(true, strength, quality, resolution, kernelSize);\n        this.blurYFilter = new BlurFilterPass(false, strength, quality, resolution, kernelSize);\n\n        this.resolution = resolution;\n        this.quality = quality;\n        this.blur = strength;\n\n        this.repeatEdgePixels = false;\n    }\n\n    /**\n     * Applies the filter.\n     * @param filterManager - The manager.\n     * @param input - The input target.\n     * @param output - The output target.\n     * @param clearMode - How to clear\n     */\n    apply(filterManager: FilterSystem, input: RenderTexture, output: RenderTexture, clearMode: CLEAR_MODES): void\n    {\n        const xStrength = Math.abs(this.blurXFilter.strength);\n        const yStrength = Math.abs(this.blurYFilter.strength);\n\n        if (xStrength && yStrength)\n        {\n            const renderTarget = filterManager.getFilterTexture();\n\n            this.blurXFilter.apply(filterManager, input, renderTarget, CLEAR_MODES.CLEAR);\n            this.blurYFilter.apply(filterManager, renderTarget, output, clearMode);\n\n            filterManager.returnFilterTexture(renderTarget);\n        }\n        else if (yStrength)\n        {\n            this.blurYFilter.apply(filterManager, input, output, clearMode);\n        }\n        else\n        {\n            this.blurXFilter.apply(filterManager, input, output, clearMode);\n        }\n    }\n\n    protected updatePadding(): void\n    {\n        if (this._repeatEdgePixels)\n        {\n            this.padding = 0;\n        }\n        else\n        {\n            this.padding = Math.max(Math.abs(this.blurXFilter.strength), Math.abs(this.blurYFilter.strength)) * 2;\n        }\n    }\n\n    /**\n     * Sets the strength of both the blurX and blurY properties simultaneously\n     * @default 2\n     */\n    get blur(): number\n    {\n        return this.blurXFilter.blur;\n    }\n\n    set blur(value: number)\n    {\n        this.blurXFilter.blur = this.blurYFilter.blur = value;\n        this.updatePadding();\n    }\n\n    /**\n     * Sets the number of passes for blur. More passes means higher quality bluring.\n     * @default 1\n     */\n    get quality(): number\n    {\n        return this.blurXFilter.quality;\n    }\n\n    set quality(value: number)\n    {\n        this.blurXFilter.quality = this.blurYFilter.quality = value;\n    }\n\n    /**\n     * Sets the strength of the blurX property\n     * @default 2\n     */\n    get blurX(): number\n    {\n        return this.blurXFilter.blur;\n    }\n\n    set blurX(value: number)\n    {\n        this.blurXFilter.blur = value;\n        this.updatePadding();\n    }\n\n    /**\n     * Sets the strength of the blurY property\n     * @default 2\n     */\n    get blurY(): number\n    {\n        return this.blurYFilter.blur;\n    }\n\n    set blurY(value: number)\n    {\n        this.blurYFilter.blur = value;\n        this.updatePadding();\n    }\n\n    /**\n     * Sets the blendmode of the filter\n     * @default PIXI.BLEND_MODES.NORMAL\n     */\n    get blendMode(): BLEND_MODES\n    {\n        return this.blurYFilter.blendMode;\n    }\n\n    set blendMode(value: BLEND_MODES)\n    {\n        this.blurYFilter.blendMode = value;\n    }\n\n    /**\n     * If set to true the edge of the target will be clamped\n     * @default false\n     */\n    get repeatEdgePixels(): boolean\n    {\n        return this._repeatEdgePixels;\n    }\n\n    set repeatEdgePixels(value: boolean)\n    {\n        this._repeatEdgePixels = value;\n        this.updatePadding();\n    }\n}\n","import { Filter, defaultFilterVertex } from '@pixi/core';\nimport fragment from './colorMatrix.frag';\n\nimport type { ArrayFixed } from '@pixi/utils';\n\nexport type ColorMatrix = ArrayFixed<number, 20>;\n\n/**\n * The ColorMatrixFilter class lets you apply a 5x4 matrix transformation on the RGBA\n * color and alpha values of every pixel on your displayObject to produce a result\n * with a new set of RGBA color and alpha values. It's pretty powerful!\n *\n * ```js\n *  let colorMatrix = new PIXI.filters.ColorMatrixFilter();\n *  container.filters = [colorMatrix];\n *  colorMatrix.contrast(2);\n * ```\n * @author Clément Chenebault <clement@goodboydigital.com>\n * @memberof PIXI.filters\n */\nexport class ColorMatrixFilter extends Filter\n{\n    public grayscale: (scale: number, multiply: boolean) => void;\n\n    constructor()\n    {\n        const uniforms = {\n            m: new Float32Array([1, 0, 0, 0, 0,\n                0, 1, 0, 0, 0,\n                0, 0, 1, 0, 0,\n                0, 0, 0, 1, 0]),\n            uAlpha: 1,\n        };\n\n        super(defaultFilterVertex, fragment, uniforms);\n\n        this.alpha = 1;\n    }\n\n    /**\n     * Transforms current matrix and set the new one\n     * @param {number[]} matrix - 5x4 matrix\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    private _loadMatrix(matrix: ColorMatrix, multiply = false): void\n    {\n        let newMatrix = matrix;\n\n        if (multiply)\n        {\n            this._multiply(newMatrix, this.uniforms.m, matrix);\n            newMatrix = this._colorMatrix(newMatrix) as any;\n        }\n\n        // set the new matrix\n        this.uniforms.m = newMatrix;\n    }\n\n    /**\n     * Multiplies two mat5's\n     * @private\n     * @param out - 5x4 matrix the receiving matrix\n     * @param a - 5x4 matrix the first operand\n     * @param b - 5x4 matrix the second operand\n     * @returns {number[]} 5x4 matrix\n     */\n    private _multiply(out: ColorMatrix, a: ColorMatrix, b: ColorMatrix): ColorMatrix\n    {\n        // Red Channel\n        out[0] = (a[0] * b[0]) + (a[1] * b[5]) + (a[2] * b[10]) + (a[3] * b[15]);\n        out[1] = (a[0] * b[1]) + (a[1] * b[6]) + (a[2] * b[11]) + (a[3] * b[16]);\n        out[2] = (a[0] * b[2]) + (a[1] * b[7]) + (a[2] * b[12]) + (a[3] * b[17]);\n        out[3] = (a[0] * b[3]) + (a[1] * b[8]) + (a[2] * b[13]) + (a[3] * b[18]);\n        out[4] = (a[0] * b[4]) + (a[1] * b[9]) + (a[2] * b[14]) + (a[3] * b[19]) + a[4];\n\n        // Green Channel\n        out[5] = (a[5] * b[0]) + (a[6] * b[5]) + (a[7] * b[10]) + (a[8] * b[15]);\n        out[6] = (a[5] * b[1]) + (a[6] * b[6]) + (a[7] * b[11]) + (a[8] * b[16]);\n        out[7] = (a[5] * b[2]) + (a[6] * b[7]) + (a[7] * b[12]) + (a[8] * b[17]);\n        out[8] = (a[5] * b[3]) + (a[6] * b[8]) + (a[7] * b[13]) + (a[8] * b[18]);\n        out[9] = (a[5] * b[4]) + (a[6] * b[9]) + (a[7] * b[14]) + (a[8] * b[19]) + a[9];\n\n        // Blue Channel\n        out[10] = (a[10] * b[0]) + (a[11] * b[5]) + (a[12] * b[10]) + (a[13] * b[15]);\n        out[11] = (a[10] * b[1]) + (a[11] * b[6]) + (a[12] * b[11]) + (a[13] * b[16]);\n        out[12] = (a[10] * b[2]) + (a[11] * b[7]) + (a[12] * b[12]) + (a[13] * b[17]);\n        out[13] = (a[10] * b[3]) + (a[11] * b[8]) + (a[12] * b[13]) + (a[13] * b[18]);\n        out[14] = (a[10] * b[4]) + (a[11] * b[9]) + (a[12] * b[14]) + (a[13] * b[19]) + a[14];\n\n        // Alpha Channel\n        out[15] = (a[15] * b[0]) + (a[16] * b[5]) + (a[17] * b[10]) + (a[18] * b[15]);\n        out[16] = (a[15] * b[1]) + (a[16] * b[6]) + (a[17] * b[11]) + (a[18] * b[16]);\n        out[17] = (a[15] * b[2]) + (a[16] * b[7]) + (a[17] * b[12]) + (a[18] * b[17]);\n        out[18] = (a[15] * b[3]) + (a[16] * b[8]) + (a[17] * b[13]) + (a[18] * b[18]);\n        out[19] = (a[15] * b[4]) + (a[16] * b[9]) + (a[17] * b[14]) + (a[18] * b[19]) + a[19];\n\n        return out;\n    }\n\n    /**\n     * Create a Float32 Array and normalize the offset component to 0-1\n     * @param {number[]} matrix - 5x4 matrix\n     * @returns {number[]} 5x4 matrix with all values between 0-1\n     */\n    private _colorMatrix(matrix: ColorMatrix): ColorMatrix\n    {\n        // Create a Float32 Array and normalize the offset component to 0-1\n        const m = new Float32Array(matrix);\n\n        m[4] /= 255;\n        m[9] /= 255;\n        m[14] /= 255;\n        m[19] /= 255;\n\n        return m as any;\n    }\n\n    /**\n     * Adjusts brightness\n     * @param b - value of the brigthness (0-1, where 0 is black)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public brightness(b: number, multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            b, 0, 0, 0, 0,\n            0, b, 0, 0, 0,\n            0, 0, b, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Sets each channel on the diagonal of the color matrix.\n     * This can be used to achieve a tinting effect on Containers similar to the tint field of some\n     * display objects like Sprite, Text, Graphics, and Mesh.\n     * @param color - Color of the tint. This is a hex value.\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public tint(color: number, multiply?: boolean): void\n    {\n        const r = (color >> 16) & 0xff;\n        const g = (color >> 8) & 0xff;\n        const b = color & 0xff;\n\n        const matrix: ColorMatrix = [\n            r / 255, 0, 0, 0, 0,\n            0, g / 255, 0, 0, 0,\n            0, 0, b / 255, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Set the matrices in grey scales\n     * @param scale - value of the grey (0-1, where 0 is black)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public greyscale(scale: number, multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            scale, scale, scale, 0, 0,\n            scale, scale, scale, 0, 0,\n            scale, scale, scale, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Set the black and white matrice.\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public blackAndWhite(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            0.3, 0.6, 0.1, 0, 0,\n            0.3, 0.6, 0.1, 0, 0,\n            0.3, 0.6, 0.1, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Set the hue property of the color\n     * @param rotation - in degrees\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public hue(rotation: number, multiply: boolean): void\n    {\n        rotation = (rotation || 0) / 180 * Math.PI;\n\n        const cosR = Math.cos(rotation);\n        const sinR = Math.sin(rotation);\n        const sqrt = Math.sqrt;\n\n        /* a good approximation for hue rotation\n         This matrix is far better than the versions with magic luminance constants\n         formerly used here, but also used in the starling framework (flash) and known from this\n         old part of the internet: quasimondo.com/archives/000565.php\n\n         This new matrix is based on rgb cube rotation in space. Look here for a more descriptive\n         implementation as a shader not a general matrix:\n         https://github.com/evanw/glfx.js/blob/58841c23919bd59787effc0333a4897b43835412/src/filters/adjust/huesaturation.js\n\n         This is the source for the code:\n         see http://stackoverflow.com/questions/8507885/shift-hue-of-an-rgb-color/8510751#8510751\n         */\n\n        const w = 1 / 3;\n        const sqrW = sqrt(w); // weight is\n\n        const a00 = cosR + ((1.0 - cosR) * w);\n        const a01 = (w * (1.0 - cosR)) - (sqrW * sinR);\n        const a02 = (w * (1.0 - cosR)) + (sqrW * sinR);\n\n        const a10 = (w * (1.0 - cosR)) + (sqrW * sinR);\n        const a11 = cosR + (w * (1.0 - cosR));\n        const a12 = (w * (1.0 - cosR)) - (sqrW * sinR);\n\n        const a20 = (w * (1.0 - cosR)) - (sqrW * sinR);\n        const a21 = (w * (1.0 - cosR)) + (sqrW * sinR);\n        const a22 = cosR + (w * (1.0 - cosR));\n\n        const matrix: ColorMatrix = [\n            a00, a01, a02, 0, 0,\n            a10, a11, a12, 0, 0,\n            a20, a21, a22, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Set the contrast matrix, increase the separation between dark and bright\n     * Increase contrast : shadows darker and highlights brighter\n     * Decrease contrast : bring the shadows up and the highlights down\n     * @param amount - value of the contrast (0-1)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public contrast(amount: number, multiply: boolean): void\n    {\n        const v = (amount || 0) + 1;\n        const o = -0.5 * (v - 1);\n\n        const matrix: ColorMatrix = [\n            v, 0, 0, 0, o,\n            0, v, 0, 0, o,\n            0, 0, v, 0, o,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Set the saturation matrix, increase the separation between colors\n     * Increase saturation : increase contrast, brightness, and sharpness\n     * @param amount - The saturation amount (0-1)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public saturate(amount = 0, multiply?: boolean): void\n    {\n        const x = (amount * 2 / 3) + 1;\n        const y = ((x - 1) * -0.5);\n\n        const matrix: ColorMatrix = [\n            x, y, y, 0, 0,\n            y, x, y, 0, 0,\n            y, y, x, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /** Desaturate image (remove color) Call the saturate function */\n    public desaturate(): void // eslint-disable-line no-unused-vars\n    {\n        this.saturate(-1);\n    }\n\n    /**\n     * Negative image (inverse of classic rgb matrix)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public negative(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            -1, 0, 0, 1, 0,\n            0, -1, 0, 1, 0,\n            0, 0, -1, 1, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Sepia image\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public sepia(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            0.393, 0.7689999, 0.18899999, 0, 0,\n            0.349, 0.6859999, 0.16799999, 0, 0,\n            0.272, 0.5339999, 0.13099999, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Color motion picture process invented in 1916 (thanks Dominic Szablewski)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public technicolor(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            1.9125277891456083, -0.8545344976951645, -0.09155508482755585, 0, 11.793603434377337,\n            -0.3087833385928097, 1.7658908555458428, -0.10601743074722245, 0, -70.35205161461398,\n            -0.231103377548616, -0.7501899197440212, 1.847597816108189, 0, 30.950940869491138,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Polaroid filter\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public polaroid(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            1.438, -0.062, -0.062, 0, 0,\n            -0.122, 1.378, -0.122, 0, 0,\n            -0.016, -0.016, 1.483, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Filter who transforms : Red -> Blue and Blue -> Red\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public toBGR(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            0, 0, 1, 0, 0,\n            0, 1, 0, 0, 0,\n            1, 0, 0, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Color reversal film introduced by Eastman Kodak in 1935. (thanks Dominic Szablewski)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public kodachrome(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            1.1285582396593525, -0.3967382283601348, -0.03992559172921793, 0, 63.72958762196502,\n            -0.16404339962244616, 1.0835251566291304, -0.05498805115633132, 0, 24.732407896706203,\n            -0.16786010706155763, -0.5603416277695248, 1.6014850761964943, 0, 35.62982807460946,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Brown delicious browni filter (thanks Dominic Szablewski)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public browni(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            0.5997023498159715, 0.34553243048391263, -0.2708298674538042, 0, 47.43192855600873,\n            -0.037703249837783157, 0.8609577587992641, 0.15059552388459913, 0, -36.96841498319127,\n            0.24113635128153335, -0.07441037908422492, 0.44972182064877153, 0, -7.562075277591283,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Vintage filter (thanks Dominic Szablewski)\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public vintage(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            0.6279345635605994, 0.3202183420819367, -0.03965408211312453, 0, 9.651285835294123,\n            0.02578397704808868, 0.6441188644374771, 0.03259127616149294, 0, 7.462829176470591,\n            0.0466055556782719, -0.0851232987247891, 0.5241648018700465, 0, 5.159190588235296,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * We don't know exactly what it does, kind of gradient map, but funny to play with!\n     * @param desaturation - Tone values.\n     * @param toned - Tone values.\n     * @param lightColor - Tone values, example: `0xFFE580`\n     * @param darkColor - Tone values, example: `0xFFE580`\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public colorTone(desaturation: number, toned: number, lightColor: number, darkColor: number, multiply: boolean): void\n    {\n        desaturation = desaturation || 0.2;\n        toned = toned || 0.15;\n        lightColor = lightColor || 0xFFE580;\n        darkColor = darkColor || 0x338000;\n\n        const lR = ((lightColor >> 16) & 0xFF) / 255;\n        const lG = ((lightColor >> 8) & 0xFF) / 255;\n        const lB = (lightColor & 0xFF) / 255;\n\n        const dR = ((darkColor >> 16) & 0xFF) / 255;\n        const dG = ((darkColor >> 8) & 0xFF) / 255;\n        const dB = (darkColor & 0xFF) / 255;\n\n        const matrix: ColorMatrix = [\n            0.3, 0.59, 0.11, 0, 0,\n            lR, lG, lB, desaturation, 0,\n            dR, dG, dB, toned, 0,\n            lR - dR, lG - dG, lB - dB, 0, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Night effect\n     * @param intensity - The intensity of the night effect.\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public night(intensity: number, multiply: boolean): void\n    {\n        intensity = intensity || 0.1;\n\n        const matrix: ColorMatrix = [\n            intensity * (-2.0), -intensity, 0, 0, 0,\n            -intensity, 0, intensity, 0, 0,\n            0, intensity, intensity * 2.0, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * Predator effect\n     *\n     * Erase the current matrix by setting a new indepent one\n     * @param amount - how much the predator feels his future victim\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public predator(amount: number, multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            // row 1\n            11.224130630493164 * amount,\n            -4.794486999511719 * amount,\n            -2.8746118545532227 * amount,\n            0 * amount,\n            0.40342438220977783 * amount,\n            // row 2\n            -3.6330697536468506 * amount,\n            9.193157196044922 * amount,\n            -2.951810836791992 * amount,\n            0 * amount,\n            -1.316135048866272 * amount,\n            // row 3\n            -3.2184197902679443 * amount,\n            -4.2375030517578125 * amount,\n            7.476448059082031 * amount,\n            0 * amount,\n            0.8044459223747253 * amount,\n            // row 4\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /**\n     * LSD effect\n     *\n     * Multiply the current matrix\n     * @param multiply - if true, current matrix and matrix are multiplied. If false,\n     *  just set the current matrix with @param matrix\n     */\n    public lsd(multiply: boolean): void\n    {\n        const matrix: ColorMatrix = [\n            2, -0.4, 0.5, 0, 0,\n            -0.5, 2, -0.4, 0, 0,\n            -0.4, -0.5, 3, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, multiply);\n    }\n\n    /** Erase the current matrix by setting the default one. */\n    public reset(): void\n    {\n        const matrix: ColorMatrix = [\n            1, 0, 0, 0, 0,\n            0, 1, 0, 0, 0,\n            0, 0, 1, 0, 0,\n            0, 0, 0, 1, 0,\n        ];\n\n        this._loadMatrix(matrix, false);\n    }\n\n    /**\n     * The matrix of the color matrix filter\n     * @member {number[]}\n     * @default [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]\n     */\n    get matrix(): ColorMatrix\n    {\n        return this.uniforms.m;\n    }\n\n    set matrix(value: ColorMatrix)\n    {\n        this.uniforms.m = value;\n    }\n\n    /**\n     * The opacity value to use when mixing the original and resultant colors.\n     *\n     * When the value is 0, the original color is used without modification.\n     * When the value is 1, the result color is used.\n     * When in the range (0, 1) the color is interpolated between the original and result by this amount.\n     * @default 1\n     */\n    get alpha(): number\n    {\n        return this.uniforms.uAlpha;\n    }\n\n    set alpha(value: number)\n    {\n        this.uniforms.uAlpha = value;\n    }\n}\n\n// Americanized alias\nColorMatrixFilter.prototype.grayscale = ColorMatrixFilter.prototype.greyscale;\n","import { Filter } from '@pixi/core';\nimport { Matrix, Point } from '@pixi/math';\nimport fragment from './displacement.frag';\nimport vertex from './displacement.vert';\n\nimport type { CLEAR_MODES } from '@pixi/constants';\nimport type { FilterSystem, RenderTexture, Texture, ISpriteMaskTarget } from '@pixi/core';\n\n/**\n * The DisplacementFilter class uses the pixel values from the specified texture\n * (called the displacement map) to perform a displacement of an object.\n *\n * You can use this filter to apply all manor of crazy warping effects.\n * Currently the `r` property of the texture is used to offset the `x`\n * and the `g` property of the texture is used to offset the `y`.\n *\n * The way it works is it uses the values of the displacement map to look up the\n * correct pixels to output. This means it's not technically moving the original.\n * Instead, it's starting at the output and asking \"which pixel from the original goes here\".\n * For example, if a displacement map pixel has `red = 1` and the filter scale is `20`,\n * this filter will output the pixel approximately 20 pixels to the right of the original.\n * @memberof PIXI.filters\n */\nexport class DisplacementFilter extends Filter\n{\n    public maskSprite: ISpriteMaskTarget;\n    public maskMatrix: Matrix;\n    public scale: Point;\n\n    /**\n     * @param {PIXI.Sprite} sprite - The sprite used for the displacement map. (make sure its added to the scene!)\n     * @param scale - The scale of the displacement\n     */\n    constructor(sprite: ISpriteMaskTarget, scale?: number)\n    {\n        const maskMatrix = new Matrix();\n\n        sprite.renderable = false;\n\n        super(vertex, fragment, {\n            mapSampler: sprite._texture,\n            filterMatrix: maskMatrix,\n            scale: { x: 1, y: 1 },\n            rotation: new Float32Array([1, 0, 0, 1]),\n        });\n\n        this.maskSprite = sprite;\n        this.maskMatrix = maskMatrix;\n\n        if (scale === null || scale === undefined)\n        {\n            scale = 20;\n        }\n\n        /**\n         * scaleX, scaleY for displacements\n         * @member {PIXI.Point}\n         */\n        this.scale = new Point(scale, scale);\n    }\n\n    /**\n     * Applies the filter.\n     * @param filterManager - The manager.\n     * @param input - The input target.\n     * @param output - The output target.\n     * @param clearMode - clearMode.\n     */\n    public apply(\n        filterManager: FilterSystem, input: RenderTexture, output: RenderTexture, clearMode: CLEAR_MODES\n    ): void\n    {\n        // fill maskMatrix with _normalized sprite texture coords_\n        this.uniforms.filterMatrix = filterManager.calculateSpriteMatrix(this.maskMatrix, this.maskSprite);\n        this.uniforms.scale.x = this.scale.x;\n        this.uniforms.scale.y = this.scale.y;\n\n        // Extract rotation from world transform\n        const wt = this.maskSprite.worldTransform;\n        const lenX = Math.sqrt((wt.a * wt.a) + (wt.b * wt.b));\n        const lenY = Math.sqrt((wt.c * wt.c) + (wt.d * wt.d));\n\n        if (lenX !== 0 && lenY !== 0)\n        {\n            this.uniforms.rotation[0] = wt.a / lenX;\n            this.uniforms.rotation[1] = wt.b / lenX;\n            this.uniforms.rotation[2] = wt.c / lenY;\n            this.uniforms.rotation[3] = wt.d / lenY;\n        }\n\n        // draw the filter...\n        filterManager.applyFilter(this, input, output, clearMode);\n    }\n\n    /** The texture used for the displacement map. Must be power of 2 sized texture. */\n    get map(): Texture\n    {\n        return this.uniforms.mapSampler;\n    }\n\n    set map(value: Texture)\n    {\n        this.uniforms.mapSampler = value;\n    }\n}\n","import { Filter } from '@pixi/core';\nimport vertex from './fxaa.vert';\nimport fragment from './fxaa.frag';\n\n/**\n * Basic FXAA (Fast Approximate Anti-Aliasing) implementation based on the code on geeks3d.com\n * with the modification that the texture2DLod stuff was removed since it is unsupported by WebGL.\n * @see https://github.com/mitsuhiko/webgl-meincraft\n * @memberof PIXI.filters\n */\nexport class FXAAFilter extends Filter\n{\n    constructor()\n    {\n        // TODO - needs work\n        super(vertex, fragment);\n    }\n}\n","import { Filter, defaultFilterVertex } from '@pixi/core';\nimport fragment from './noise.frag';\n\n/**\n * A Noise effect filter.\n *\n * original filter: https://github.com/evanw/glfx.js/blob/master/src/filters/adjust/noise.js\n * @memberof PIXI.filters\n * @author Vico @vicocotea\n */\nexport class NoiseFilter extends Filter\n{\n    /**\n     * @param {number} [noise=0.5] - The noise intensity, should be a normalized value in the range [0, 1].\n     * @param {number} [seed] - A random seed for the noise generation. Default is `Math.random()`.\n     */\n    constructor(noise = 0.5, seed = Math.random())\n    {\n        super(defaultFilterVertex, fragment, {\n            uNoise: 0,\n            uSeed: 0,\n        });\n\n        this.noise = noise;\n        this.seed = seed;\n    }\n\n    /**\n     * The amount of noise to apply, this value should be in the range (0, 1].\n     * @default 0.5\n     */\n    get noise(): number\n    {\n        return this.uniforms.uNoise;\n    }\n\n    set noise(value: number)\n    {\n        this.uniforms.uNoise = value;\n    }\n\n    /** A seed value to apply to the random noise generation. `Math.random()` is a good value to use. */\n    get seed(): number\n    {\n        return this.uniforms.uSeed;\n    }\n\n    set seed(value: number)\n    {\n        this.uniforms.uSeed = value;\n    }\n}\n","import type { Renderer, MaskData, AbstractRenderer } from '@pixi/core';\nimport { Texture, BaseTexture, RenderTexture } from '@pixi/core';\nimport { Sprite } from '@pixi/sprite';\nimport type { Container, IDestroyOptions } from '@pixi/display';\nimport { DisplayObject } from '@pixi/display';\nimport type { IPointData, Rectangle } from '@pixi/math';\nimport { Matrix } from '@pixi/math';\nimport { uid } from '@pixi/utils';\nimport { settings } from '@pixi/settings';\nimport { MSAA_QUALITY } from '@pixi/constants';\n\n// Don't import CanvasRender to remove dependency on this optional package\n// this type should satisify these requirements for cacheAsBitmap types\ninterface CanvasRenderer extends AbstractRenderer\n{\n    context: CanvasRenderingContext2D;\n}\n\nconst _tempMatrix = new Matrix();\n\nDisplayObject.prototype._cacheAsBitmap = false;\nDisplayObject.prototype._cacheData = null;\nDisplayObject.prototype._cacheAsBitmapResolution = null;\nDisplayObject.prototype._cacheAsBitmapMultisample = MSAA_QUALITY.NONE;\n\n// figured there's no point adding ALL the extra variables to prototype.\n// this model can hold the information needed. This can also be generated on demand as\n// most objects are not cached as bitmaps.\n/**\n * @class\n * @ignore\n * @private\n */\nexport class CacheData\n{\n    public textureCacheId: string;\n    public originalRender: (renderer: Renderer) => void;\n    public originalRenderCanvas: (renderer: AbstractRenderer) => void;\n    public originalCalculateBounds: () => void;\n    public originalGetLocalBounds: (rect?: Rectangle) => Rectangle;\n    public originalUpdateTransform: () => void;\n    public originalDestroy: (options?: IDestroyOptions | boolean) => void;\n    public originalMask: Container | MaskData;\n    public originalFilterArea: Rectangle;\n    public originalContainsPoint: (point: IPointData) => boolean;\n    public sprite: Sprite;\n\n    constructor()\n    {\n        this.textureCacheId = null;\n\n        this.originalRender = null;\n        this.originalRenderCanvas = null;\n        this.originalCalculateBounds = null;\n        this.originalGetLocalBounds = null;\n\n        this.originalUpdateTransform = null;\n        this.originalDestroy = null;\n        this.originalMask = null;\n        this.originalFilterArea = null;\n        this.originalContainsPoint = null;\n        this.sprite = null;\n    }\n}\n\nObject.defineProperties(DisplayObject.prototype, {\n    /**\n     * The resolution to use for cacheAsBitmap. By default this will use the renderer's resolution\n     * but can be overriden for performance. Lower values will reduce memory usage at the expense\n     * of render quality. A falsey value of `null` or `0` will default to the renderer's resolution.\n     * If `cacheAsBitmap` is set to `true`, this will re-render with the new resolution.\n     * @member {number} cacheAsBitmapResolution\n     * @memberof PIXI.DisplayObject#\n     * @default null\n     */\n    cacheAsBitmapResolution: {\n        get(): number\n        {\n            return this._cacheAsBitmapResolution;\n        },\n        set(resolution: number): void\n        {\n            if (resolution === this._cacheAsBitmapResolution)\n            {\n                return;\n            }\n\n            this._cacheAsBitmapResolution = resolution;\n\n            if (this.cacheAsBitmap)\n            {\n                // Toggle to re-render at the new resolution\n                this.cacheAsBitmap = false;\n                this.cacheAsBitmap = true;\n            }\n        },\n    },\n\n    /**\n     * The number of samples to use for cacheAsBitmap. If set to `null`, the renderer's\n     * sample count is used.\n     * If `cacheAsBitmap` is set to `true`, this will re-render with the new number of samples.\n     * @member {number} cacheAsBitmapMultisample\n     * @memberof PIXI.DisplayObject#\n     * @default PIXI.MSAA_QUALITY.NONE\n     */\n    cacheAsBitmapMultisample: {\n        get(): MSAA_QUALITY\n        {\n            return this._cacheAsBitmapMultisample;\n        },\n        set(multisample: MSAA_QUALITY): void\n        {\n            if (multisample === this._cacheAsBitmapMultisample)\n            {\n                return;\n            }\n\n            this._cacheAsBitmapMultisample = multisample;\n\n            if (this.cacheAsBitmap)\n            {\n                // Toggle to re-render with new multisample\n                this.cacheAsBitmap = false;\n                this.cacheAsBitmap = true;\n            }\n        },\n    },\n\n    /**\n     * Set this to true if you want this display object to be cached as a bitmap.\n     * This basically takes a snap shot of the display object as it is at that moment. It can\n     * provide a performance benefit for complex static displayObjects.\n     * To remove simply set this property to `false`\n     *\n     * IMPORTANT GOTCHA - Make sure that all your textures are preloaded BEFORE setting this property to true\n     * as it will take a snapshot of what is currently there. If the textures have not loaded then they will not appear.\n     * @member {boolean}\n     * @memberof PIXI.DisplayObject#\n     */\n    cacheAsBitmap: {\n        get(): CacheData\n        {\n            return this._cacheAsBitmap;\n        },\n        set(value: CacheData): void\n        {\n            if (this._cacheAsBitmap === value)\n            {\n                return;\n            }\n\n            this._cacheAsBitmap = value;\n\n            let data: CacheData;\n\n            if (value)\n            {\n                if (!this._cacheData)\n                {\n                    this._cacheData = new CacheData();\n                }\n\n                data = this._cacheData;\n\n                data.originalRender = this.render;\n                data.originalRenderCanvas = this.renderCanvas;\n\n                data.originalUpdateTransform = this.updateTransform;\n                data.originalCalculateBounds = this.calculateBounds;\n                data.originalGetLocalBounds = this.getLocalBounds;\n\n                data.originalDestroy = this.destroy;\n\n                data.originalContainsPoint = this.containsPoint;\n\n                data.originalMask = this._mask;\n                data.originalFilterArea = this.filterArea;\n\n                this.render = this._renderCached;\n                this.renderCanvas = this._renderCachedCanvas;\n\n                this.destroy = this._cacheAsBitmapDestroy;\n            }\n            else\n            {\n                data = this._cacheData;\n\n                if (data.sprite)\n                {\n                    this._destroyCachedDisplayObject();\n                }\n\n                this.render = data.originalRender;\n                this.renderCanvas = data.originalRenderCanvas;\n                this.calculateBounds = data.originalCalculateBounds;\n                this.getLocalBounds = data.originalGetLocalBounds;\n\n                this.destroy = data.originalDestroy;\n\n                this.updateTransform = data.originalUpdateTransform;\n                this.containsPoint = data.originalContainsPoint;\n\n                this._mask = data.originalMask;\n                this.filterArea = data.originalFilterArea;\n            }\n        },\n    },\n});\n\n/**\n * Renders a cached version of the sprite with WebGL\n * @private\n * @method _renderCached\n * @memberof PIXI.DisplayObject#\n * @param {PIXI.Renderer} renderer - the WebGL renderer\n */\nDisplayObject.prototype._renderCached = function _renderCached(renderer: Renderer): void\n{\n    if (!this.visible || this.worldAlpha <= 0 || !this.renderable)\n    {\n        return;\n    }\n\n    this._initCachedDisplayObject(renderer);\n\n    this._cacheData.sprite.transform._worldID = this.transform._worldID;\n    this._cacheData.sprite.worldAlpha = this.worldAlpha;\n    (this._cacheData.sprite as any)._render(renderer);\n};\n\n/**\n * Prepares the WebGL renderer to cache the sprite\n * @private\n * @method _initCachedDisplayObject\n * @memberof PIXI.DisplayObject#\n * @param {PIXI.Renderer} renderer - the WebGL renderer\n */\nDisplayObject.prototype._initCachedDisplayObject = function _initCachedDisplayObject(renderer: Renderer): void\n{\n    if (this._cacheData && this._cacheData.sprite)\n    {\n        return;\n    }\n\n    // make sure alpha is set to 1 otherwise it will get rendered as invisible!\n    const cacheAlpha = this.alpha;\n\n    this.alpha = 1;\n\n    // first we flush anything left in the renderer (otherwise it would get rendered to the cached texture)\n    renderer.batch.flush();\n    // this.filters= [];\n\n    // next we find the dimensions of the untransformed object\n    // this function also calls updatetransform on all its children as part of the measuring.\n    // This means we don't need to update the transform again in this function\n    // TODO pass an object to clone too? saves having to create a new one each time!\n    const bounds = (this as Container).getLocalBounds(null, true).clone();\n\n    // add some padding!\n    if (this.filters && this.filters.length)\n    {\n        const padding = this.filters[0].padding;\n\n        bounds.pad(padding);\n    }\n\n    bounds.ceil(settings.RESOLUTION);\n\n    // for now we cache the current renderTarget that the WebGL renderer is currently using.\n    // this could be more elegant..\n    const cachedRenderTexture = renderer.renderTexture.current;\n    const cachedSourceFrame = renderer.renderTexture.sourceFrame.clone();\n    const cachedDestinationFrame = renderer.renderTexture.destinationFrame.clone();\n    const cachedProjectionTransform = renderer.projection.transform;\n\n    // We also store the filter stack - I will definitely look to change how this works a little later down the line.\n    // const stack = renderer.filterManager.filterStack;\n\n    // this renderTexture will be used to store the cached DisplayObject\n    const renderTexture = RenderTexture.create({\n        width: bounds.width,\n        height: bounds.height,\n        resolution: this.cacheAsBitmapResolution || renderer.resolution,\n        multisample: this.cacheAsBitmapMultisample ?? renderer.multisample,\n    });\n\n    const textureCacheId = `cacheAsBitmap_${uid()}`;\n\n    this._cacheData.textureCacheId = textureCacheId;\n\n    BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);\n    Texture.addToCache(renderTexture, textureCacheId);\n\n    // need to set //\n    const m = this.transform.localTransform.copyTo(_tempMatrix).invert().translate(-bounds.x, -bounds.y);\n\n    // set all properties to there original so we can render to a texture\n    this.render = this._cacheData.originalRender;\n\n    renderer.render(this, { renderTexture, clear: true, transform: m, skipUpdateTransform: false });\n    renderer.framebuffer.blit();\n\n    // now restore the state be setting the new properties\n    renderer.projection.transform = cachedProjectionTransform;\n    renderer.renderTexture.bind(cachedRenderTexture, cachedSourceFrame, cachedDestinationFrame);\n\n    // renderer.filterManager.filterStack = stack;\n\n    this.render = this._renderCached;\n    // the rest is the same as for Canvas\n    this.updateTransform = this.displayObjectUpdateTransform;\n    this.calculateBounds = this._calculateCachedBounds;\n    this.getLocalBounds = this._getCachedLocalBounds;\n\n    this._mask = null;\n    this.filterArea = null;\n    this.alpha = cacheAlpha;\n\n    // create our cached sprite\n    const cachedSprite = new Sprite(renderTexture);\n\n    cachedSprite.transform.worldTransform = this.transform.worldTransform;\n    cachedSprite.anchor.x = -(bounds.x / bounds.width);\n    cachedSprite.anchor.y = -(bounds.y / bounds.height);\n    cachedSprite.alpha = cacheAlpha;\n    cachedSprite._bounds = this._bounds;\n\n    this._cacheData.sprite = cachedSprite;\n\n    this.transform._parentID = -1;\n    // restore the transform of the cached sprite to avoid the nasty flicker..\n    if (!this.parent)\n    {\n        this.enableTempParent();\n        this.updateTransform();\n        this.disableTempParent(null);\n    }\n    else\n    {\n        this.updateTransform();\n    }\n\n    // map the hit test..\n    (this as Sprite).containsPoint = cachedSprite.containsPoint.bind(cachedSprite);\n};\n\n/**\n * Renders a cached version of the sprite with canvas\n * @private\n * @method _renderCachedCanvas\n * @memberof PIXI.DisplayObject#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer\n */\nDisplayObject.prototype._renderCachedCanvas = function _renderCachedCanvas(renderer: AbstractRenderer): void\n{\n    if (!this.visible || this.worldAlpha <= 0 || !this.renderable)\n    {\n        return;\n    }\n\n    this._initCachedDisplayObjectCanvas(renderer);\n\n    this._cacheData.sprite.worldAlpha = this.worldAlpha;\n    (this._cacheData.sprite as any)._renderCanvas(renderer);\n};\n\n// TODO this can be the same as the WebGL version.. will need to do a little tweaking first though..\n/**\n * Prepares the Canvas renderer to cache the sprite\n * @private\n * @method _initCachedDisplayObjectCanvas\n * @memberof PIXI.DisplayObject#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer\n */\nDisplayObject.prototype._initCachedDisplayObjectCanvas = function _initCachedDisplayObjectCanvas(\n    renderer: CanvasRenderer\n): void\n{\n    if (this._cacheData && this._cacheData.sprite)\n    {\n        return;\n    }\n\n    // get bounds actually transforms the object for us already!\n    const bounds = (this as Container).getLocalBounds(null, true);\n\n    const cacheAlpha = this.alpha;\n\n    this.alpha = 1;\n\n    const cachedRenderTarget = renderer.context;\n    const cachedProjectionTransform = (renderer as any)._projTransform;\n\n    bounds.ceil(settings.RESOLUTION);\n\n    const renderTexture = RenderTexture.create({ width: bounds.width, height: bounds.height });\n\n    const textureCacheId = `cacheAsBitmap_${uid()}`;\n\n    this._cacheData.textureCacheId = textureCacheId;\n\n    BaseTexture.addToCache(renderTexture.baseTexture, textureCacheId);\n    Texture.addToCache(renderTexture, textureCacheId);\n\n    // need to set //\n    const m = _tempMatrix;\n\n    this.transform.localTransform.copyTo(m);\n    m.invert();\n\n    m.tx -= bounds.x;\n    m.ty -= bounds.y;\n\n    // m.append(this.transform.worldTransform.)\n    // set all properties to there original so we can render to a texture\n    this.renderCanvas = this._cacheData.originalRenderCanvas;\n\n    renderer.render(this, { renderTexture, clear: true, transform: m, skipUpdateTransform: false });\n    // now restore the state be setting the new properties\n    renderer.context = cachedRenderTarget;\n    (renderer as any)._projTransform = cachedProjectionTransform;\n\n    this.renderCanvas = this._renderCachedCanvas;\n    // the rest is the same as for WebGL\n    this.updateTransform = this.displayObjectUpdateTransform;\n    this.calculateBounds = this._calculateCachedBounds;\n    this.getLocalBounds = this._getCachedLocalBounds;\n\n    this._mask = null;\n    this.filterArea = null;\n    this.alpha = cacheAlpha;\n\n    // create our cached sprite\n    const cachedSprite = new Sprite(renderTexture);\n\n    cachedSprite.transform.worldTransform = this.transform.worldTransform;\n    cachedSprite.anchor.x = -(bounds.x / bounds.width);\n    cachedSprite.anchor.y = -(bounds.y / bounds.height);\n    cachedSprite.alpha = cacheAlpha;\n    cachedSprite._bounds = this._bounds;\n\n    this._cacheData.sprite = cachedSprite;\n\n    this.transform._parentID = -1;\n    // restore the transform of the cached sprite to avoid the nasty flicker..\n    if (!this.parent)\n    {\n        this.parent = (renderer as any)._tempDisplayObjectParent;\n        this.updateTransform();\n        this.parent = null;\n    }\n    else\n    {\n        this.updateTransform();\n    }\n\n    // map the hit test..\n    (this as Sprite).containsPoint = cachedSprite.containsPoint.bind(cachedSprite);\n};\n\n/**\n * Calculates the bounds of the cached sprite\n * @private\n * @method\n */\nDisplayObject.prototype._calculateCachedBounds = function _calculateCachedBounds(): void\n{\n    this._bounds.clear();\n    this._cacheData.sprite.transform._worldID = this.transform._worldID;\n    (this._cacheData.sprite as any)._calculateBounds();\n    this._bounds.updateID = (this as any)._boundsID;\n};\n\n/**\n * Gets the bounds of the cached sprite.\n * @private\n * @method\n * @returns {Rectangle} The local bounds.\n */\nDisplayObject.prototype._getCachedLocalBounds = function _getCachedLocalBounds(): Rectangle\n{\n    return this._cacheData.sprite.getLocalBounds(null);\n};\n\n/**\n * Destroys the cached sprite.\n * @private\n * @method\n */\nDisplayObject.prototype._destroyCachedDisplayObject = function _destroyCachedDisplayObject(): void\n{\n    this._cacheData.sprite._texture.destroy(true);\n    this._cacheData.sprite = null;\n\n    BaseTexture.removeFromCache(this._cacheData.textureCacheId);\n    Texture.removeFromCache(this._cacheData.textureCacheId);\n\n    this._cacheData.textureCacheId = null;\n};\n\n/**\n * Destroys the cached object.\n * @private\n * @method\n * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options\n *  have been set to that value.\n *  Used when destroying containers, see the Container.destroy method.\n */\nDisplayObject.prototype._cacheAsBitmapDestroy = function _cacheAsBitmapDestroy(options?: IDestroyOptions | boolean): void\n{\n    this.cacheAsBitmap = false;\n    this.destroy(options);\n};\n","import { DisplayObject, Container } from '@pixi/display';\n\n/**\n * The instance name of the object.\n * @memberof PIXI.DisplayObject#\n * @member {string} name\n */\nDisplayObject.prototype.name = null;\n\n/**\n * Returns the display object in the container.\n *\n * Recursive searches are done in a preorder traversal.\n * @method getChildByName\n * @memberof PIXI.Container#\n * @param {string} name - Instance name.\n * @param {boolean}[deep=false] - Whether to search recursively\n * @returns {PIXI.DisplayObject} The child with the specified name.\n */\nContainer.prototype.getChildByName = function getChildByName<T extends DisplayObject = DisplayObject>(\n    name: string,\n    deep?: boolean,\n): T\n{\n    for (let i = 0, j = this.children.length; i < j; i++)\n    {\n        if (this.children[i].name === name)\n        {\n            return this.children[i];\n        }\n    }\n\n    if (deep)\n    {\n        for (let i = 0, j = this.children.length; i < j; i++)\n        {\n            const child = (this.children[i] as Container);\n\n            if (!child.getChildByName)\n            {\n                continue;\n            }\n\n            const target = child.getChildByName<T>(name, true);\n\n            if (target)\n            {\n                return target;\n            }\n        }\n    }\n\n    return null;\n};\n","import { DisplayObject } from '@pixi/display';\nimport { Point } from '@pixi/math';\n\n/**\n * Returns the global position of the displayObject. Does not depend on object scale, rotation and pivot.\n * @method getGlobalPosition\n * @memberof PIXI.DisplayObject#\n * @param {PIXI.Point} [point=new PIXI.Point()] - The point to write the global value to.\n * @param {boolean} [skipUpdate=false] - Setting to true will stop the transforms of the scene graph from\n *  being updated. This means the calculation returned MAY be out of date BUT will give you a\n *  nice performance boost.\n * @returns {PIXI.Point} The updated point.\n */\nDisplayObject.prototype.getGlobalPosition = function getGlobalPosition(point: Point = new Point(), skipUpdate = false): Point\n{\n    if (this.parent)\n    {\n        this.parent.toGlobal(this.position, point, skipUpdate);\n    }\n    else\n    {\n        point.x = this.position.x;\n        point.y = this.position.y;\n    }\n\n    return point;\n};\n","import type { ExtensionMetadata, Renderer } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\nimport type { IApplicationOptions } from './Application';\n\ntype ResizeableRenderer = Pick<Renderer, 'resize'>;\n\n/**\n * Middleware for for Application's resize functionality\n * @private\n * @class\n */\nexport class ResizePlugin\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = ExtensionType.Application;\n\n    public static resizeTo: Window | HTMLElement;\n    public static resize: () => void;\n    public static renderer: ResizeableRenderer;\n    public static queueResize: () => void;\n    private static _resizeId: number;\n    private static _resizeTo: Window | HTMLElement;\n    private static cancelResize: () => void;\n\n    /**\n     * Initialize the plugin with scope of application instance\n     * @static\n     * @private\n     * @param {object} [options] - See application options\n     */\n    static init(options?: IApplicationOptions): void\n    {\n        Object.defineProperty(this, 'resizeTo',\n            /**\n             * The HTML element or window to automatically resize the\n             * renderer's view element to match width and height.\n             * @member {Window|HTMLElement}\n             * @name resizeTo\n             * @memberof PIXI.Application#\n             */\n            {\n                set(dom: Window | HTMLElement)\n                {\n                    globalThis.removeEventListener('resize', this.queueResize);\n                    this._resizeTo = dom;\n                    if (dom)\n                    {\n                        globalThis.addEventListener('resize', this.queueResize);\n                        this.resize();\n                    }\n                },\n                get()\n                {\n                    return this._resizeTo;\n                },\n            });\n\n        /**\n         * Resize is throttled, so it's safe to call this multiple times per frame and it'll\n         * only be called once.\n         * @memberof PIXI.Application#\n         * @method queueResize\n         * @private\n         */\n        this.queueResize = (): void =>\n        {\n            if (!this._resizeTo)\n            {\n                return;\n            }\n\n            this.cancelResize();\n\n            // // Throttle resize events per raf\n            this._resizeId = requestAnimationFrame(() => this.resize());\n        };\n\n        /**\n         * Cancel the resize queue.\n         * @memberof PIXI.Application#\n         * @method cancelResize\n         * @private\n         */\n        this.cancelResize = (): void =>\n        {\n            if (this._resizeId)\n            {\n                cancelAnimationFrame(this._resizeId);\n                this._resizeId = null;\n            }\n        };\n\n        /**\n         * Execute an immediate resize on the renderer, this is not\n         * throttled and can be expensive to call many times in a row.\n         * Will resize only if `resizeTo` property is set.\n         * @memberof PIXI.Application#\n         * @method resize\n         */\n        this.resize = (): void =>\n        {\n            if (!this._resizeTo)\n            {\n                return;\n            }\n\n            // clear queue resize\n            this.cancelResize();\n\n            let width: number;\n            let height: number;\n\n            // Resize to the window\n            if (this._resizeTo === globalThis.window)\n            {\n                width = globalThis.innerWidth;\n                height = globalThis.innerHeight;\n            }\n            // Resize to other HTML entities\n            else\n            {\n                const { clientWidth, clientHeight } = this._resizeTo as HTMLElement;\n\n                width = clientWidth;\n                height = clientHeight;\n            }\n\n            this.renderer.resize(width, height);\n        };\n\n        // On resize\n        this._resizeId = null;\n        this._resizeTo = null;\n        this.resizeTo = options.resizeTo || null;\n    }\n\n    /**\n     * Clean up the ticker, scoped to application\n     * @static\n     * @private\n     */\n    static destroy(): void\n    {\n        globalThis.removeEventListener('resize', this.queueResize);\n        this.cancelResize();\n        this.cancelResize = null;\n        this.queueResize = null;\n        this.resizeTo = null;\n        this.resize = null;\n    }\n}\n","import { Container } from '@pixi/display';\nimport { autoDetectRenderer, extensions, ExtensionType } from '@pixi/core';\n\nimport type { Rectangle } from '@pixi/math';\nimport type { Renderer, IRendererOptionsAuto, AbstractRenderer } from '@pixi/core';\nimport type { IDestroyOptions } from '@pixi/display';\nimport { deprecation } from '@pixi/utils';\n\n/**\n * Any plugin that's usable for Application should contain these methods.\n * @memberof PIXI\n */\nexport interface IApplicationPlugin\n{\n    /**\n     * Called when Application is constructed, scoped to Application instance.\n     * Passes in `options` as the only argument, which are Application constructor options.\n     * @param {object} options - Application options.\n     */\n    init(options: IApplicationOptions): void;\n    /** Called when destroying Application, scoped to Application instance. */\n    destroy(): void;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface IApplicationOptions extends IRendererOptionsAuto, GlobalMixins.IApplicationOptions {}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface Application extends GlobalMixins.Application {}\n\n/**\n * Convenience class to create a new PIXI application.\n *\n * This class automatically creates the renderer, ticker and root container.\n * @example\n * // Create the application\n * const app = new PIXI.Application();\n *\n * // Add the view to the DOM\n * document.body.appendChild(app.view);\n *\n * // ex, add display objects\n * app.stage.addChild(PIXI.Sprite.from('something.png'));\n * @class\n * @memberof PIXI\n */\nexport class Application\n{\n    /** Collection of installed plugins. */\n    static _plugins: IApplicationPlugin[] = [];\n\n    /**\n     * The root display container that's rendered.\n     * @member {PIXI.Container}\n     */\n    public stage: Container = new Container();\n\n    /**\n     * WebGL renderer if available, otherwise CanvasRenderer.\n     * @member {PIXI.Renderer|PIXI.CanvasRenderer}\n     */\n    public renderer: Renderer | AbstractRenderer;\n\n    /**\n     * @param {object} [options] - The optional renderer parameters.\n     * @param {boolean} [options.autoStart=true] - Automatically starts the rendering after the construction.\n     *     **Note**: Setting this parameter to false does NOT stop the shared ticker even if you set\n     *     options.sharedTicker to true in case that it is already started. Stop it by your own.\n     * @param {number} [options.width=800] - The width of the renderers view.\n     * @param {number} [options.height=600] - The height of the renderers view.\n     * @param {HTMLCanvasElement} [options.view] - The canvas to use as a view, optional.\n     * @param {boolean} [options.useContextAlpha=true] - Pass-through value for canvas' context `alpha` property.\n     *   If you want to set transparency, please use `backgroundAlpha`. This option is for cases where the\n     *   canvas needs to be opaque, possibly for performance reasons on some older devices.\n     * @param {boolean} [options.autoDensity=false] - Resizes renderer view in CSS pixels to allow for\n     *   resolutions other than 1.\n     * @param {boolean} [options.antialias=false] - Sets antialias\n     * @param {boolean} [options.preserveDrawingBuffer=false] - Enables drawing buffer preservation, enable this if you\n     *  need to call toDataUrl on the WebGL context.\n     * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio of the renderer.\n     * @param {boolean} [options.forceCanvas=false] - prevents selection of WebGL renderer, even if such is present, this\n     *   option only is available when using **pixi.js-legacy** or **@pixi/canvas-renderer** modules, otherwise\n     *   it is ignored.\n     * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area\n     *  (shown if not transparent).\n     * @param {number} [options.backgroundAlpha=1] - Value from 0 (fully transparent) to 1 (fully opaque).\n     * @param {boolean} [options.transparent] - **Deprecated**. `true` sets backgroundAlpha to 0,\n     *  `false` sets backgroundAlpha to 1.\n     * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or\n     *   not before the new render pass.\n     * @param {string} [options.powerPreference] - Parameter passed to webgl context, set to \"high-performance\"\n     *  for devices with dual graphics card. **(WebGL only)**.\n     * @param {boolean} [options.sharedTicker=false] - `true` to use PIXI.Ticker.shared, `false` to create new ticker.\n     *  If set to false, you cannot register a handler to occur before anything that runs on the shared ticker.\n     *  The system ticker will always run before both the shared ticker and the app ticker.\n     * @param {boolean} [options.sharedLoader=false] - `true` to use PIXI.Loader.shared, `false` to create new Loader.\n     * @param {Window|HTMLElement} [options.resizeTo] - Element to automatically resize stage to.\n     */\n    constructor(options?: IApplicationOptions)\n    {\n        // The default options\n        options = Object.assign({\n            forceCanvas: false,\n        }, options);\n\n        this.renderer = autoDetectRenderer(options);\n\n        // install plugins here\n        Application._plugins.forEach((plugin) =>\n        {\n            plugin.init.call(this, options);\n        });\n    }\n\n    /**\n     * Use the {@link PIXI.extensions.add} API to register plugins.\n     * @deprecated since 6.5.0\n     * @static\n     * @param {PIXI.IApplicationPlugin} plugin - Plugin being installed\n     */\n    static registerPlugin(plugin: IApplicationPlugin): void\n    {\n        // #if _DEBUG\n        deprecation('6.5.0', 'Application.registerPlugin() is deprecated, use extensions.add()');\n        // #endif\n        extensions.add({\n            type: ExtensionType.Application,\n            ref: plugin,\n        });\n    }\n\n    /** Render the current stage. */\n    public render(): void\n    {\n        this.renderer.render(this.stage);\n    }\n\n    /**\n     * Reference to the renderer's canvas element.\n     * @member {HTMLCanvasElement}\n     * @readonly\n     */\n    get view(): HTMLCanvasElement\n    {\n        return this.renderer.view;\n    }\n\n    /**\n     * Reference to the renderer's screen rectangle. Its safe to use as `filterArea` or `hitArea` for the whole screen.\n     * @member {PIXI.Rectangle}\n     * @readonly\n     */\n    get screen(): Rectangle\n    {\n        return this.renderer.screen;\n    }\n\n    /**\n     * Destroy and don't use after this.\n     * @param {boolean} [removeView=false] - Automatically remove canvas from DOM.\n     * @param {object|boolean} [stageOptions] - Options parameter. A boolean will act as if all options\n     *  have been set to that value\n     * @param {boolean} [stageOptions.children=false] - if set to true, all the children will have their destroy\n     *  method called as well. 'stageOptions' will be passed on to those calls.\n     * @param {boolean} [stageOptions.texture=false] - Only used for child Sprites if stageOptions.children is set\n     *  to true. Should it destroy the texture of the child sprite\n     * @param {boolean} [stageOptions.baseTexture=false] - Only used for child Sprites if stageOptions.children is set\n     *  to true. Should it destroy the base texture of the child sprite\n     */\n    public destroy(removeView?: boolean, stageOptions?: IDestroyOptions | boolean): void\n    {\n        // Destroy plugins in the opposite order\n        // which they were constructed\n        const plugins = Application._plugins.slice(0);\n\n        plugins.reverse();\n        plugins.forEach((plugin) =>\n        {\n            plugin.destroy.call(this);\n        });\n\n        this.stage.destroy(stageOptions);\n        this.stage = null;\n\n        this.renderer.destroy(removeView);\n        this.renderer = null;\n    }\n}\n\nextensions.handleByList(ExtensionType.Application, Application._plugins);\n","import { ResizePlugin } from './ResizePlugin';\nimport { extensions } from '@pixi/core';\n\nextensions.add(ResizePlugin);\n\nexport * from './Application';\nexport { ResizePlugin };\n","import { Texture } from '@pixi/core';\nimport { Sprite } from '@pixi/sprite';\nimport { Ticker, UPDATE_PRIORITY } from '@pixi/ticker';\nimport type { IDestroyOptions } from '@pixi/display';\n\n/**\n * An AnimatedSprite is a simple way to display an animation depicted by a list of textures.\n *\n * ```js\n * let alienImages = [\"image_sequence_01.png\",\"image_sequence_02.png\",\"image_sequence_03.png\",\"image_sequence_04.png\"];\n * let textureArray = [];\n *\n * for (let i=0; i < 4; i++)\n * {\n *      let texture = PIXI.Texture.from(alienImages[i]);\n *      textureArray.push(texture);\n * };\n *\n * let animatedSprite = new PIXI.AnimatedSprite(textureArray);\n * ```\n *\n * The more efficient and simpler way to create an animated sprite is using a {@link PIXI.Spritesheet}\n * containing the animation definitions:\n *\n * ```js\n * PIXI.Loader.shared.add(\"assets/spritesheet.json\").load(setup);\n *\n * function setup() {\n *   let sheet = PIXI.Loader.shared.resources[\"assets/spritesheet.json\"].spritesheet;\n *   animatedSprite = new PIXI.AnimatedSprite(sheet.animations[\"image_sequence\"]);\n *   ...\n * }\n * ```\n * @memberof PIXI\n */\nexport class AnimatedSprite extends Sprite\n{\n    /**\n     * The speed that the AnimatedSprite will play at. Higher is faster, lower is slower.\n     * @default 1\n     */\n    public animationSpeed: number;\n\n    /**\n     * Whether or not the animate sprite repeats after playing.\n     * @default true\n     */\n    public loop: boolean;\n\n    /**\n     * Update anchor to [Texture's defaultAnchor]{@link PIXI.Texture#defaultAnchor} when frame changes.\n     *\n     * Useful with [sprite sheet animations]{@link PIXI.Spritesheet#animations} created with tools.\n     * Changing anchor for each frame allows to pin sprite origin to certain moving feature\n     * of the frame (e.g. left foot).\n     *\n     * Note: Enabling this will override any previously set `anchor` on each frame change.\n     * @default false\n     */\n    public updateAnchor: boolean;\n\n    /**\n     * User-assigned function to call when an AnimatedSprite finishes playing.\n     * @example\n     * animation.onComplete = function () {\n     *   // finished!\n     * };\n     */\n    public onComplete?: () => void;\n\n    /**\n     * User-assigned function to call when an AnimatedSprite changes which texture is being rendered.\n     * @example\n     * animation.onFrameChange = function () {\n     *   // updated!\n     * };\n     */\n    public onFrameChange?: (currentFrame: number) => void;\n\n    /**\n     * User-assigned function to call when `loop` is true, and an AnimatedSprite is played and\n     * loops around to start again.\n     * @example\n     * animation.onLoop = function () {\n     *   // looped!\n     * };\n     */\n    public onLoop?: () => void;\n\n    private _playing: boolean;\n    private _textures: Texture[];\n    private _durations: number[];\n\n    /**\n     * `true` uses PIXI.Ticker.shared to auto update animation time.\n     * @default true\n     */\n    private _autoUpdate: boolean;\n\n    /**\n     * `true` if the instance is currently connected to PIXI.Ticker.shared to auto update animation time.\n     * @default false\n     */\n    private _isConnectedToTicker: boolean;\n\n    /** Elapsed time since animation has been started, used internally to display current texture. */\n    private _currentTime: number;\n\n    /** The texture index that was displayed last time. */\n    private _previousFrame: number;\n\n    /**\n     * @param textures - An array of {@link PIXI.Texture} or frame\n     *  objects that make up the animation.\n     * @param {boolean} [autoUpdate=true] - Whether to use PIXI.Ticker.shared to auto update animation time.\n     */\n    constructor(textures: Texture[] | FrameObject[], autoUpdate = true)\n    {\n        super(textures[0] instanceof Texture ? textures[0] : textures[0].texture);\n\n        this._textures = null;\n        this._durations = null;\n        this._autoUpdate = autoUpdate;\n        this._isConnectedToTicker = false;\n\n        this.animationSpeed = 1;\n        this.loop = true;\n        this.updateAnchor = false;\n        this.onComplete = null;\n        this.onFrameChange = null;\n        this.onLoop = null;\n\n        this._currentTime = 0;\n\n        this._playing = false;\n        this._previousFrame = null;\n\n        this.textures = textures;\n    }\n\n    /** Stops the AnimatedSprite. */\n    public stop(): void\n    {\n        if (!this._playing)\n        {\n            return;\n        }\n\n        this._playing = false;\n        if (this._autoUpdate && this._isConnectedToTicker)\n        {\n            Ticker.shared.remove(this.update, this);\n            this._isConnectedToTicker = false;\n        }\n    }\n\n    /** Plays the AnimatedSprite. */\n    public play(): void\n    {\n        if (this._playing)\n        {\n            return;\n        }\n\n        this._playing = true;\n        if (this._autoUpdate && !this._isConnectedToTicker)\n        {\n            Ticker.shared.add(this.update, this, UPDATE_PRIORITY.HIGH);\n            this._isConnectedToTicker = true;\n        }\n    }\n\n    /**\n     * Stops the AnimatedSprite and goes to a specific frame.\n     * @param frameNumber - Frame index to stop at.\n     */\n    public gotoAndStop(frameNumber: number): void\n    {\n        this.stop();\n\n        const previousFrame = this.currentFrame;\n\n        this._currentTime = frameNumber;\n\n        if (previousFrame !== this.currentFrame)\n        {\n            this.updateTexture();\n        }\n    }\n\n    /**\n     * Goes to a specific frame and begins playing the AnimatedSprite.\n     * @param frameNumber - Frame index to start at.\n     */\n    public gotoAndPlay(frameNumber: number): void\n    {\n        const previousFrame = this.currentFrame;\n\n        this._currentTime = frameNumber;\n\n        if (previousFrame !== this.currentFrame)\n        {\n            this.updateTexture();\n        }\n\n        this.play();\n    }\n\n    /**\n     * Updates the object transform for rendering.\n     * @param deltaTime - Time since last tick.\n     */\n    update(deltaTime: number): void\n    {\n        if (!this._playing)\n        {\n            return;\n        }\n\n        const elapsed = this.animationSpeed * deltaTime;\n        const previousFrame = this.currentFrame;\n\n        if (this._durations !== null)\n        {\n            let lag = this._currentTime % 1 * this._durations[this.currentFrame];\n\n            lag += elapsed / 60 * 1000;\n\n            while (lag < 0)\n            {\n                this._currentTime--;\n                lag += this._durations[this.currentFrame];\n            }\n\n            const sign = Math.sign(this.animationSpeed * deltaTime);\n\n            this._currentTime = Math.floor(this._currentTime);\n\n            while (lag >= this._durations[this.currentFrame])\n            {\n                lag -= this._durations[this.currentFrame] * sign;\n                this._currentTime += sign;\n            }\n\n            this._currentTime += lag / this._durations[this.currentFrame];\n        }\n        else\n        {\n            this._currentTime += elapsed;\n        }\n\n        if (this._currentTime < 0 && !this.loop)\n        {\n            this.gotoAndStop(0);\n\n            if (this.onComplete)\n            {\n                this.onComplete();\n            }\n        }\n        else if (this._currentTime >= this._textures.length && !this.loop)\n        {\n            this.gotoAndStop(this._textures.length - 1);\n\n            if (this.onComplete)\n            {\n                this.onComplete();\n            }\n        }\n        else if (previousFrame !== this.currentFrame)\n        {\n            if (this.loop && this.onLoop)\n            {\n                if (this.animationSpeed > 0 && this.currentFrame < previousFrame)\n                {\n                    this.onLoop();\n                }\n                else if (this.animationSpeed < 0 && this.currentFrame > previousFrame)\n                {\n                    this.onLoop();\n                }\n            }\n\n            this.updateTexture();\n        }\n    }\n\n    /** Updates the displayed texture to match the current frame index. */\n    private updateTexture(): void\n    {\n        const currentFrame = this.currentFrame;\n\n        if (this._previousFrame === currentFrame)\n        {\n            return;\n        }\n\n        this._previousFrame = currentFrame;\n\n        this._texture = this._textures[currentFrame];\n        this._textureID = -1;\n        this._textureTrimmedID = -1;\n        this._cachedTint = 0xFFFFFF;\n        this.uvs = this._texture._uvs.uvsFloat32;\n\n        if (this.updateAnchor)\n        {\n            this._anchor.copyFrom(this._texture.defaultAnchor);\n        }\n\n        if (this.onFrameChange)\n        {\n            this.onFrameChange(this.currentFrame);\n        }\n    }\n\n    /**\n     * Stops the AnimatedSprite and destroys it.\n     * @param {object|boolean} [options] - Options parameter. A boolean will act as if all options\n     *  have been set to that value.\n     * @param {boolean} [options.children=false] - If set to true, all the children will have their destroy\n     *      method called as well. 'options' will be passed on to those calls.\n     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the sprite as well.\n     * @param {boolean} [options.baseTexture=false] - Should it destroy the base texture of the sprite as well.\n     */\n    public destroy(options?: IDestroyOptions | boolean): void\n    {\n        this.stop();\n        super.destroy(options);\n\n        this.onComplete = null;\n        this.onFrameChange = null;\n        this.onLoop = null;\n    }\n\n    /**\n     * A short hand way of creating an AnimatedSprite from an array of frame ids.\n     * @param frames - The array of frames ids the AnimatedSprite will use as its texture frames.\n     * @returns - The new animated sprite with the specified frames.\n     */\n    public static fromFrames(frames: string[]): AnimatedSprite\n    {\n        const textures = [];\n\n        for (let i = 0; i < frames.length; ++i)\n        {\n            textures.push(Texture.from(frames[i]));\n        }\n\n        return new AnimatedSprite(textures);\n    }\n\n    /**\n     * A short hand way of creating an AnimatedSprite from an array of image ids.\n     * @param images - The array of image urls the AnimatedSprite will use as its texture frames.\n     * @returns The new animate sprite with the specified images as frames.\n     */\n    public static fromImages(images: string[]): AnimatedSprite\n    {\n        const textures = [];\n\n        for (let i = 0; i < images.length; ++i)\n        {\n            textures.push(Texture.from(images[i]));\n        }\n\n        return new AnimatedSprite(textures);\n    }\n\n    /**\n     * The total number of frames in the AnimatedSprite. This is the same as number of textures\n     * assigned to the AnimatedSprite.\n     * @readonly\n     * @default 0\n     */\n    get totalFrames(): number\n    {\n        return this._textures.length;\n    }\n\n    /** The array of textures used for this AnimatedSprite. */\n    get textures(): Texture[] | FrameObject[]\n    {\n        return this._textures;\n    }\n\n    set textures(value: Texture[] | FrameObject[])\n    {\n        if (value[0] instanceof Texture)\n        {\n            this._textures = value as Texture[];\n            this._durations = null;\n        }\n        else\n        {\n            this._textures = [];\n            this._durations = [];\n\n            for (let i = 0; i < value.length; i++)\n            {\n                this._textures.push((value[i] as FrameObject).texture);\n                this._durations.push((value[i] as FrameObject).time);\n            }\n        }\n        this._previousFrame = null;\n        this.gotoAndStop(0);\n        this.updateTexture();\n    }\n\n    /**\n     * The AnimatedSprites current frame index.\n     * @readonly\n     */\n    get currentFrame(): number\n    {\n        let currentFrame = Math.floor(this._currentTime) % this._textures.length;\n\n        if (currentFrame < 0)\n        {\n            currentFrame += this._textures.length;\n        }\n\n        return currentFrame;\n    }\n\n    /**\n     * Indicates if the AnimatedSprite is currently playing.\n     * @readonly\n     */\n    get playing(): boolean\n    {\n        return this._playing;\n    }\n\n    /** Whether to use PIXI.Ticker.shared to auto update animation time. */\n    get autoUpdate(): boolean\n    {\n        return this._autoUpdate;\n    }\n\n    set autoUpdate(value: boolean)\n    {\n        if (value !== this._autoUpdate)\n        {\n            this._autoUpdate = value;\n\n            if (!this._autoUpdate && this._isConnectedToTicker)\n            {\n                Ticker.shared.remove(this.update, this);\n                this._isConnectedToTicker = false;\n            }\n            else if (this._autoUpdate && !this._isConnectedToTicker && this._playing)\n            {\n                Ticker.shared.add(this.update, this);\n                this._isConnectedToTicker = true;\n            }\n        }\n    }\n}\n\n/** @memberof PIXI.AnimatedSprite */\nexport interface FrameObject\n{\n    /** The {@link PIXI.Texture} of the frame. */\n    texture: Texture;\n\n    /** The duration of the frame, in milliseconds. */\n    time: number;\n}\n","import '@pixi/polyfill';\n\nimport * as utils from '@pixi/utils';\nimport { AccessibilityManager } from '@pixi/accessibility';\nimport { InteractionManager } from '@pixi/interaction';\nimport { BatchRenderer, extensions } from '@pixi/core';\nimport { Extract } from '@pixi/extract';\nimport { AppLoaderPlugin } from '@pixi/loaders';\nimport { CompressedTextureLoader, DDSLoader, KTXLoader } from '@pixi/compressed-textures';\nimport { ParticleRenderer } from '@pixi/particle-container';\nimport { Prepare } from '@pixi/prepare';\nimport { SpritesheetLoader } from '@pixi/spritesheet';\nimport { TilingSpriteRenderer } from '@pixi/sprite-tiling';\nimport { BitmapFontLoader } from '@pixi/text-bitmap';\nimport { TickerPlugin } from '@pixi/ticker';\nimport { AlphaFilter } from '@pixi/filter-alpha';\nimport { BlurFilter, BlurFilterPass } from '@pixi/filter-blur';\nimport { ColorMatrixFilter } from '@pixi/filter-color-matrix';\nimport { DisplacementFilter } from '@pixi/filter-displacement';\nimport { FXAAFilter } from '@pixi/filter-fxaa';\nimport { NoiseFilter } from '@pixi/filter-noise';\nimport '@pixi/mixin-cache-as-bitmap';\nimport '@pixi/mixin-get-child-by-name';\nimport '@pixi/mixin-get-global-position';\n\nextensions.add(\n    // Install renderer plugins\n    AccessibilityManager,\n    Extract,\n    InteractionManager,\n    ParticleRenderer,\n    Prepare,\n    BatchRenderer,\n    TilingSpriteRenderer,\n\n    // Install loader plugins\n    BitmapFontLoader,\n    CompressedTextureLoader,\n    DDSLoader,\n    KTXLoader,\n    SpritesheetLoader,\n\n    // Install application plugins\n    TickerPlugin,\n    AppLoaderPlugin\n);\n\n/**\n * This namespace contains WebGL-only display filters that can be applied\n * to DisplayObjects using the {@link PIXI.DisplayObject#filters filters} property.\n *\n * Since PixiJS only had a handful of built-in filters, additional filters\n * can be downloaded {@link https://github.com/pixijs/pixi-filters here} from the\n * PixiJS Filters repository.\n *\n * All filters must extend {@link PIXI.Filter}.\n * @example\n * // Create a new application\n * const app = new PIXI.Application();\n *\n * // Draw a green rectangle\n * const rect = new PIXI.Graphics()\n *     .beginFill(0x00ff00)\n *     .drawRect(40, 40, 200, 200);\n *\n * // Add a blur filter\n * rect.filters = [new PIXI.filters.BlurFilter()];\n *\n * // Display rectangle\n * app.stage.addChild(rect);\n * document.body.appendChild(app.view);\n * @namespace PIXI.filters\n */\nexport const filters = {\n    AlphaFilter,\n    BlurFilter,\n    BlurFilterPass,\n    ColorMatrixFilter,\n    DisplacementFilter,\n    FXAAFilter,\n    NoiseFilter,\n};\n\n// Export ES for those importing specifically by name,\nexport * from '@pixi/accessibility';\nexport * from '@pixi/app';\nexport * from '@pixi/constants';\nexport * from '@pixi/compressed-textures';\nexport * from '@pixi/core';\nexport * from '@pixi/display';\nexport * from '@pixi/extract';\nexport * from '@pixi/graphics';\nexport * from '@pixi/loaders';\nexport * from '@pixi/interaction';\nexport * from '@pixi/math';\nexport * from '@pixi/mesh';\nexport * from '@pixi/mesh-extras';\nexport * from '@pixi/particle-container';\nexport * from '@pixi/prepare';\nexport * from '@pixi/runner';\nexport * from '@pixi/sprite';\nexport * from '@pixi/spritesheet';\nexport * from '@pixi/sprite-animated';\nexport * from '@pixi/sprite-tiling';\nexport * from '@pixi/text';\nexport * from '@pixi/text-bitmap';\nexport * from '@pixi/ticker';\nexport * from '@pixi/settings';\nexport { utils };\n","import type { Polygon } from '@pixi/math';\nimport { SHAPES } from '@pixi/math';\n\nimport type { CanvasRenderer } from '../CanvasRenderer';\nimport type { Graphics } from '@pixi/graphics';\nimport type { MaskData } from '@pixi/core';\nimport type { Container } from '@pixi/display';\n\n/**\n * A set of functions used to handle masking.\n *\n * Sprite masking is not supported on the CanvasRenderer.\n * @class\n * @memberof PIXI\n */\nexport class CanvasMaskManager\n{\n    /** A reference to the current renderer */\n    private renderer: CanvasRenderer;\n    private _foundShapes: Array<Graphics> = [];\n\n    /** @param renderer - A reference to the current renderer */\n    constructor(renderer: CanvasRenderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * This method adds it to the current stack of masks.\n     * @param maskData - the maskData that will be pushed\n     */\n    pushMask(maskData: MaskData | Graphics): void\n    {\n        const renderer = this.renderer;\n        const maskObject = ((maskData as MaskData).maskObject || maskData) as Container;\n\n        renderer.context.save();\n\n        // TODO support sprite alpha masks??\n        // lots of effort required. If demand is great enough..\n\n        const foundShapes = this._foundShapes;\n\n        this.recursiveFindShapes(maskObject, foundShapes);\n        if (foundShapes.length > 0)\n        {\n            const { context } = renderer;\n\n            context.beginPath();\n\n            for (let i = 0; i < foundShapes.length; i++)\n            {\n                const shape = foundShapes[i];\n                const transform = shape.transform.worldTransform;\n\n                this.renderer.setContextTransform(transform);\n\n                this.renderGraphicsShape(shape);\n            }\n\n            foundShapes.length = 0;\n            context.clip();\n        }\n    }\n\n    /**\n     * Renders all PIXI.Graphics shapes in a subtree.\n     * @param container - container to scan.\n     * @param out - where to put found shapes\n     */\n    recursiveFindShapes(container: Container, out: Array<Graphics>): void\n    {\n        if ((container as Graphics).geometry && (container as Graphics).geometry.graphicsData)\n        {\n            out.push(container as Graphics);\n        }\n\n        const { children } = container;\n\n        if (children)\n        {\n            for (let i = 0; i < children.length; i++)\n            {\n                this.recursiveFindShapes(children[i] as Container, out);\n            }\n        }\n    }\n\n    /**\n     * Renders a PIXI.Graphics shape.\n     * @param graphics - The object to render.\n     */\n    renderGraphicsShape(graphics: Graphics): void\n    {\n        graphics.finishPoly();\n\n        const context = this.renderer.context;\n        const graphicsData = graphics.geometry.graphicsData;\n        const len = graphicsData.length;\n\n        if (len === 0)\n        {\n            return;\n        }\n\n        for (let i = 0; i < len; i++)\n        {\n            const data = graphicsData[i];\n            const shape = data.shape;\n\n            if (shape.type === SHAPES.POLY)\n            {\n                let points = shape.points;\n                const holes = data.holes;\n                let outerArea;\n                let innerArea;\n                let px;\n                let py;\n\n                context.moveTo(points[0], points[1]);\n\n                for (let j = 1; j < points.length / 2; j++)\n                {\n                    context.lineTo(points[j * 2], points[(j * 2) + 1]);\n                }\n                if (holes.length > 0)\n                {\n                    outerArea = 0;\n                    px = points[0];\n                    py = points[1];\n                    for (let j = 2; j + 2 < points.length; j += 2)\n                    {\n                        outerArea += ((points[j] - px) * (points[j + 3] - py))\n                            - ((points[j + 2] - px) * (points[j + 1] - py));\n                    }\n\n                    for (let k = 0; k < holes.length; k++)\n                    {\n                        points = (holes[k].shape as Polygon).points;\n\n                        if (!points)\n                        {\n                            continue;\n                        }\n\n                        innerArea = 0;\n                        px = points[0];\n                        py = points[1];\n                        for (let j = 2; j + 2 < points.length; j += 2)\n                        {\n                            innerArea += ((points[j] - px) * (points[j + 3] - py))\n                                - ((points[j + 2] - px) * (points[j + 1] - py));\n                        }\n\n                        if (innerArea * outerArea < 0)\n                        {\n                            context.moveTo(points[0], points[1]);\n\n                            for (let j = 2; j < points.length; j += 2)\n                            {\n                                context.lineTo(points[j], points[j + 1]);\n                            }\n                        }\n                        else\n                        {\n                            context.moveTo(points[points.length - 2], points[points.length - 1]);\n\n                            for (let j = points.length - 4; j >= 0; j -= 2)\n                            {\n                                context.lineTo(points[j], points[j + 1]);\n                            }\n                        }\n\n                        if ((holes[k].shape as Polygon).closeStroke)\n                        {\n                            context.closePath();\n                        }\n                    }\n                }\n                // if the first and last point are the same close the path - much neater :)\n                if (points[0] === points[points.length - 2] && points[1] === points[points.length - 1])\n                {\n                    context.closePath();\n                }\n            }\n            else if (shape.type === SHAPES.RECT)\n            {\n                context.rect(shape.x, shape.y, shape.width, shape.height);\n                context.closePath();\n            }\n            else if (shape.type === SHAPES.CIRC)\n            {\n                // TODO - need to be Undefined!\n                context.arc(shape.x, shape.y, shape.radius, 0, 2 * Math.PI);\n                context.closePath();\n            }\n            else if (shape.type === SHAPES.ELIP)\n            {\n                // ellipse code taken from: http://stackoverflow.com/questions/2172798/how-to-draw-an-oval-in-html5-canvas\n\n                const w = shape.width * 2;\n                const h = shape.height * 2;\n\n                const x = shape.x - (w / 2);\n                const y = shape.y - (h / 2);\n\n                const kappa = 0.5522848;\n                const ox = (w / 2) * kappa; // control point offset horizontal\n                const oy = (h / 2) * kappa; // control point offset vertical\n                const xe = x + w; // x-end\n                const ye = y + h; // y-end\n                const xm = x + (w / 2); // x-middle\n                const ym = y + (h / 2); // y-middle\n\n                context.moveTo(x, ym);\n                context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);\n                context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);\n                context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);\n                context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);\n                context.closePath();\n            }\n            else if (shape.type === SHAPES.RREC)\n            {\n                const rx = shape.x;\n                const ry = shape.y;\n                const width = shape.width;\n                const height = shape.height;\n                let radius = shape.radius;\n\n                const maxRadius = Math.min(width, height) / 2;\n\n                radius = radius > maxRadius ? maxRadius : radius;\n\n                context.moveTo(rx, ry + radius);\n                context.lineTo(rx, ry + height - radius);\n                context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);\n                context.lineTo(rx + width - radius, ry + height);\n                context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);\n                context.lineTo(rx + width, ry + radius);\n                context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);\n                context.lineTo(rx + radius, ry);\n                context.quadraticCurveTo(rx, ry, rx, ry + radius);\n                context.closePath();\n            }\n        }\n    }\n\n    /**\n     * Restores the current drawing context to the state it was before the mask was applied.\n     * @param renderer - The renderer context to use.\n     */\n    popMask(renderer: CanvasRenderer): void\n    {\n        renderer.context.restore();\n        renderer.invalidateBlendMode();\n    }\n\n    /** Destroys this canvas mask manager. */\n    public destroy(): void\n    {\n        /* empty */\n    }\n}\n","import { settings } from '@pixi/settings';\n\n/**\n * Creates a little colored canvas\n * @ignore\n * @param {string} color - The color to make the canvas\n * @returns {HTMLCanvasElement} a small canvas element\n */\nfunction createColoredCanvas(color: string): HTMLCanvasElement\n{\n    const canvas = settings.ADAPTER.createCanvas(6, 1);\n    const context = canvas.getContext('2d');\n\n    context.fillStyle = color;\n    context.fillRect(0, 0, 6, 1);\n\n    return canvas;\n}\n\n/**\n * Checks whether the Canvas BlendModes are supported by the current browser\n * @private\n * @returns {boolean} whether they are supported\n */\nexport function canUseNewCanvasBlendModes(): boolean\n{\n    if (typeof document === 'undefined')\n    {\n        return false;\n    }\n\n    const magenta = createColoredCanvas('#ff00ff');\n    const yellow = createColoredCanvas('#ffff00');\n\n    const canvas = settings.ADAPTER.createCanvas(6, 1);\n    const context = canvas.getContext('2d');\n\n    context.globalCompositeOperation = 'multiply';\n    context.drawImage(magenta, 0, 0);\n    context.drawImage(yellow, 2, 0);\n\n    const imageData = context.getImageData(2, 0, 1, 1);\n\n    if (!imageData)\n    {\n        return false;\n    }\n\n    const data = imageData.data;\n\n    return (data[0] === 255 && data[1] === 0 && data[2] === 0);\n}\n","import {\n    AbstractRenderer,\n    CanvasResource,\n    RenderTexture,\n    BaseRenderTexture,\n    extensions,\n    ExtensionType } from '@pixi/core';\nimport { CanvasRenderTarget, sayHello, rgb2hex, hex2string, deprecation } from '@pixi/utils';\nimport { CanvasMaskManager } from './utils/CanvasMaskManager';\nimport { mapCanvasBlendModesToPixi } from './utils/mapCanvasBlendModesToPixi';\nimport { RENDERER_TYPE, SCALE_MODES, BLEND_MODES } from '@pixi/constants';\nimport { settings } from '@pixi/settings';\nimport { Matrix } from '@pixi/math';\n\nimport type { DisplayObject } from '@pixi/display';\nimport type {\n    IRendererOptions,\n    IRendererPlugin,\n    IRendererPlugins,\n    IRendererRenderOptions\n} from '@pixi/core';\n\nconst tempMatrix = new Matrix();\n\nexport interface ICanvasRendererPluginConstructor\n{\n    new (renderer: CanvasRenderer, options?: any): IRendererPlugin;\n}\n\nexport interface ICanvasRendererPlugins\n{\n    [key: string]: any;\n}\n\n/*\n * Different browsers support different smoothing property names\n * this is the list of all platform props.\n */\ntype SmoothingEnabledProperties =\n    'imageSmoothingEnabled' |\n    'webkitImageSmoothingEnabled' |\n    'mozImageSmoothingEnabled' |\n    'oImageSmoothingEnabled' |\n    'msImageSmoothingEnabled';\n\n/**\n * Rendering context for all browsers. This includes platform-specific\n * properties that are not included in the spec for CanvasRenderingContext2D\n * @private\n */\nexport interface CrossPlatformCanvasRenderingContext2D extends CanvasRenderingContext2D\n{\n    webkitImageSmoothingEnabled: boolean;\n    mozImageSmoothingEnabled: boolean;\n    oImageSmoothingEnabled: boolean;\n    msImageSmoothingEnabled: boolean;\n}\n\n/**\n * The CanvasRenderer draws the scene and all its content onto a 2d canvas.\n *\n * This renderer should be used for browsers that do not support WebGL.\n * Don't forget to add the CanvasRenderer.view to your DOM or you will not see anything!\n * @class\n * @memberof PIXI\n * @extends PIXI.AbstractRenderer\n */\nexport class CanvasRenderer extends AbstractRenderer\n{\n    /**\n     * Fired after rendering finishes.\n     * @event PIXI.CanvasRenderer#postrender\n     */\n    /**\n     * Fired before rendering starts.\n     * @event PIXI.CanvasRenderer#prerender\n     */\n\n    /** The root canvas 2d context that everything is drawn with. */\n    public readonly rootContext: CrossPlatformCanvasRenderingContext2D;\n    /** The currently active canvas 2d context (could change with renderTextures) */\n    public context: CrossPlatformCanvasRenderingContext2D;\n    /** Boolean flag controlling canvas refresh. */\n    public refresh = true;\n    /**\n     * Instance of a CanvasMaskManager, handles masking when using the canvas renderer.\n     * @member {PIXI.CanvasMaskManager}\n     */\n    public maskManager: CanvasMaskManager = new CanvasMaskManager(this);\n    /** The canvas property used to set the canvas smoothing property. */\n    public smoothProperty: SmoothingEnabledProperties = 'imageSmoothingEnabled';\n    /** Tracks the blend modes useful for this renderer. */\n    public readonly blendModes: string[] = mapCanvasBlendModesToPixi();\n    public renderingToScreen = false;\n\n    private _activeBlendMode: BLEND_MODES = null;\n    /** Projection transform, passed in render() stored here */\n    private _projTransform: Matrix = null;\n\n    /** @private */\n    _outerBlend = false;\n\n    /**\n     * @param options - The optional renderer parameters\n     * @param {number} [options.width=800] - the width of the screen\n     * @param {number} [options.height=600] - the height of the screen\n     * @param {HTMLCanvasElement} [options.view] - the canvas to use as a view, optional\n     * @param {boolean} [options.useContextAlpha=true] - Pass-through value for canvas' context `alpha` property.\n     *   If you want to set transparency, please use `backgroundAlpha`. This option is for cases where the\n     *   canvas needs to be opaque, possibly for performance reasons on some older devices.\n     * @param {boolean} [options.autoDensity=false] - Resizes renderer view in CSS pixels to allow for\n     *   resolutions other than 1\n     * @param {boolean} [options.antialias=false] - sets antialias\n     * @param {number} [options.resolution=PIXI.settings.RESOLUTION] - The resolution / device pixel ratio of the renderer.\n     * @param {boolean} [options.preserveDrawingBuffer=false] - enables drawing buffer preservation,\n     *  enable this if you need to call toDataUrl on the webgl context.\n     * @param {boolean} [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or\n     *      not before the new render pass.\n     * @param {number} [options.backgroundColor=0x000000] - The background color of the rendered area\n     *  (shown if not transparent).\n     * @param {number} [options.backgroundAlpha=1] - Value from 0 (fully transparent) to 1 (fully opaque).\n     * @param {boolean} [options.transparent] − **Deprecated**. `true` sets backgroundAlpha to 0,\n     *  `false` sets backgroundAlpha to 1.\n     */\n    constructor(options?: IRendererOptions)\n    {\n        super(RENDERER_TYPE.CANVAS, options);\n\n        this.rootContext = this.view.getContext('2d', { alpha: this.useContextAlpha }) as\n            CrossPlatformCanvasRenderingContext2D;\n\n        this.context = this.rootContext;\n\n        if (!this.rootContext.imageSmoothingEnabled)\n        {\n            const rc = this.rootContext;\n\n            if (rc.webkitImageSmoothingEnabled)\n            {\n                this.smoothProperty = 'webkitImageSmoothingEnabled';\n            }\n            else if (rc.mozImageSmoothingEnabled)\n            {\n                this.smoothProperty = 'mozImageSmoothingEnabled';\n            }\n            else if (rc.oImageSmoothingEnabled)\n            {\n                this.smoothProperty = 'oImageSmoothingEnabled';\n            }\n            else if (rc.msImageSmoothingEnabled)\n            {\n                this.smoothProperty = 'msImageSmoothingEnabled';\n            }\n        }\n\n        this.initPlugins(CanvasRenderer.__plugins);\n\n        sayHello('Canvas');\n\n        this.resize(this.options.width, this.options.height);\n    }\n\n    /** Adds a new system to the renderer. It does nothing in the CanvasRenderer. */\n    addSystem(): this\n    {\n        return this;\n    }\n\n    /**\n     * Renders the object to its WebGL view.\n     * @param displayObject - The object to be rendered.\n     * @param options - Object to use for render options.\n     * @param {PIXI.RenderTexture} [options.renderTexture] - The render texture to render to.\n     * @param {boolean} [options.clear=true] - Should the canvas be cleared before the new render.\n     * @param {PIXI.Matrix} [options.transform] - A transform to apply to the render texture before rendering.\n     * @param {boolean} [options.skipUpdateTransform=false] - Should we skip the update transform pass?\n     */\n    render(displayObject: DisplayObject, options?: IRendererRenderOptions): void;\n\n    /**\n     * Please use the `option` render arguments instead.\n     * @deprecated Since 6.0.0\n     * @param displayObject - The object to be rendered.\n     * @param renderTexture - The render texture to render to.\n     * @param clear - Should the canvas be cleared before the new render.\n     * @param transform - A transform to apply to the render texture before rendering.\n     * @param skipUpdateTransform - Should we skip the update transform pass?\n     */\n    render(displayObject: DisplayObject, renderTexture?: RenderTexture | BaseRenderTexture,\n        clear?: boolean, transform?: Matrix, skipUpdateTransform?: boolean): void;\n\n    /** @ignore */\n    public render(displayObject: DisplayObject, options?: IRendererRenderOptions | RenderTexture | BaseRenderTexture): void\n    {\n        if (!this.view)\n        {\n            return;\n        }\n\n        let renderTexture: BaseRenderTexture | RenderTexture;\n        let clear: boolean;\n        let transform: Matrix;\n        let skipUpdateTransform: boolean;\n\n        if (options)\n        {\n            if (options instanceof RenderTexture || options instanceof BaseRenderTexture)\n            {\n                // #if _DEBUG\n                deprecation('6.0.0', 'CanvasRenderer#render arguments changed, use options instead.');\n                // #endif\n\n                /* eslint-disable prefer-rest-params */\n                renderTexture = options;\n                clear = arguments[2];\n                transform = arguments[3];\n                skipUpdateTransform = arguments[4];\n                /* eslint-enable prefer-rest-params */\n            }\n            else\n            {\n                renderTexture = options.renderTexture;\n                clear = options.clear;\n                transform = options.transform;\n                skipUpdateTransform = options.skipUpdateTransform;\n            }\n        }\n\n        // can be handy to know!\n        this.renderingToScreen = !renderTexture;\n\n        this.emit('prerender');\n\n        const rootResolution = this.resolution;\n\n        if (renderTexture)\n        {\n            renderTexture = renderTexture.castToBaseTexture() as BaseRenderTexture;\n\n            if (!renderTexture._canvasRenderTarget)\n            {\n                renderTexture._canvasRenderTarget = new CanvasRenderTarget(\n                    renderTexture.width,\n                    renderTexture.height,\n                    renderTexture.resolution\n                );\n                renderTexture.resource = new CanvasResource(renderTexture._canvasRenderTarget.canvas);\n                renderTexture.valid = true;\n            }\n\n            this.context = renderTexture._canvasRenderTarget.context as CrossPlatformCanvasRenderingContext2D;\n            this.resolution = renderTexture._canvasRenderTarget.resolution;\n        }\n        else\n        {\n            this.context = this.rootContext;\n        }\n\n        const context = this.context;\n\n        this._projTransform = transform || null;\n\n        if (!renderTexture)\n        {\n            this._lastObjectRendered = displayObject;\n        }\n\n        if (!skipUpdateTransform)\n        {\n            // update the scene graph\n            const cacheParent = displayObject.enableTempParent();\n\n            displayObject.updateTransform();\n            displayObject.disableTempParent(cacheParent);\n        }\n\n        context.save();\n        context.setTransform(1, 0, 0, 1, 0, 0);\n        context.globalAlpha = 1;\n        this._activeBlendMode = BLEND_MODES.NORMAL;\n        this._outerBlend = false;\n        context.globalCompositeOperation = this.blendModes[BLEND_MODES.NORMAL];\n\n        if (clear !== undefined ? clear : this.clearBeforeRender)\n        {\n            if (this.renderingToScreen)\n            {\n                context.clearRect(0, 0, this.width, this.height);\n\n                if (this.backgroundAlpha > 0)\n                {\n                    context.globalAlpha = this.useContextAlpha ? this.backgroundAlpha : 1;\n                    context.fillStyle = this._backgroundColorString;\n                    context.fillRect(0, 0, this.width, this.height);\n                    context.globalAlpha = 1;\n                }\n            }\n            else\n            {\n                renderTexture = (renderTexture as BaseRenderTexture);\n                renderTexture._canvasRenderTarget.clear();\n\n                const clearColor = renderTexture.clearColor;\n\n                if (clearColor[3] > 0)\n                {\n                    context.globalAlpha = this.useContextAlpha ? clearColor[3] : 1;\n                    context.fillStyle = hex2string(rgb2hex(clearColor));\n                    context.fillRect(0, 0, renderTexture.realWidth, renderTexture.realHeight);\n                    context.globalAlpha = 1;\n                }\n            }\n        }\n\n        // TODO RENDER TARGET STUFF HERE..\n        const tempContext = this.context;\n\n        this.context = context;\n        displayObject.renderCanvas(this);\n        this.context = tempContext;\n\n        context.restore();\n\n        this.resolution = rootResolution;\n        this._projTransform = null;\n\n        this.emit('postrender');\n    }\n\n    /**\n     * Sets matrix of context.\n     * called only from render() methods\n     * takes care about resolution\n     * @param transform - world matrix of current element\n     * @param roundPixels - whether to round (tx,ty) coords\n     * @param localResolution - If specified, used instead of `renderer.resolution` for local scaling\n     */\n    setContextTransform(transform: Matrix, roundPixels?: boolean, localResolution?: number): void\n    {\n        let mat = transform;\n        const proj = this._projTransform;\n        const resolution = this.resolution;\n\n        localResolution = localResolution || resolution;\n\n        if (proj)\n        {\n            mat = tempMatrix;\n            mat.copyFrom(transform);\n            mat.prepend(proj);\n        }\n\n        if (roundPixels)\n        {\n            this.context.setTransform(\n                mat.a * localResolution,\n                mat.b * localResolution,\n                mat.c * localResolution,\n                mat.d * localResolution,\n                (mat.tx * resolution) | 0,\n                (mat.ty * resolution) | 0\n            );\n        }\n        else\n        {\n            this.context.setTransform(\n                mat.a * localResolution,\n                mat.b * localResolution,\n                mat.c * localResolution,\n                mat.d * localResolution,\n                mat.tx * resolution,\n                mat.ty * resolution\n            );\n        }\n    }\n\n    /**\n     * Clear the canvas of renderer.\n     * @param {string} [clearColor] - Clear the canvas with this color, except the canvas is transparent.\n     * @param {number} [alpha] - Alpha to apply to the background fill color.\n     */\n    public clear(clearColor: string = this._backgroundColorString, alpha: number = this.backgroundAlpha): void\n    {\n        const { context } = this;\n\n        context.clearRect(0, 0, this.width, this.height);\n\n        if (clearColor)\n        {\n            context.globalAlpha = this.useContextAlpha ? alpha : 1;\n            context.fillStyle = clearColor;\n            context.fillRect(0, 0, this.width, this.height);\n            context.globalAlpha = 1;\n        }\n    }\n\n    /**\n     * Sets the blend mode of the renderer.\n     * @param {number} blendMode - See {@link PIXI.BLEND_MODES} for valid values.\n     * @param {boolean} [readyForOuterBlend=false] - Some blendModes are dangerous, they affect outer space of sprite.\n     * Pass `true` only if you are ready to use them.\n     */\n    setBlendMode(blendMode: BLEND_MODES, readyForOuterBlend?: boolean): void\n    {\n        const outerBlend = blendMode === BLEND_MODES.SRC_IN\n            || blendMode === BLEND_MODES.SRC_OUT\n            || blendMode === BLEND_MODES.DST_IN\n            || blendMode === BLEND_MODES.DST_ATOP;\n\n        if (!readyForOuterBlend && outerBlend)\n        {\n            blendMode = BLEND_MODES.NORMAL;\n        }\n\n        if (this._activeBlendMode === blendMode)\n        {\n            return;\n        }\n\n        this._activeBlendMode = blendMode;\n        this._outerBlend = outerBlend;\n        this.context.globalCompositeOperation = this.blendModes[blendMode];\n    }\n\n    /**\n     * Removes everything from the renderer and optionally removes the Canvas DOM element.\n     * @param {boolean} [removeView=false] - Removes the Canvas element from the DOM.\n     */\n    public destroy(removeView?: boolean): void\n    {\n        // call the base destroy\n        super.destroy(removeView);\n\n        this.context = null;\n\n        this.refresh = true;\n\n        this.maskManager.destroy();\n        this.maskManager = null;\n\n        this.smoothProperty = null;\n    }\n\n    /**\n     * Resizes the canvas view to the specified width and height.\n     * @extends PIXI.AbstractRenderer#resize\n     * @param desiredScreenWidth - the desired width of the screen\n     * @param desiredScreenHeight - the desired height of the screen\n     */\n    public resize(desiredScreenWidth: number, desiredScreenHeight: number): void\n    {\n        super.resize(desiredScreenWidth, desiredScreenHeight);\n\n        // reset the scale mode.. oddly this seems to be reset when the canvas is resized.\n        // surely a browser bug?? Let PixiJS fix that for you..\n        if (this.smoothProperty)\n        {\n            this.rootContext[this.smoothProperty] = (settings.SCALE_MODE === SCALE_MODES.LINEAR);\n        }\n    }\n\n    /** Checks if blend mode has changed. */\n    invalidateBlendMode(): void\n    {\n        this._activeBlendMode = this.blendModes.indexOf(this.context.globalCompositeOperation);\n    }\n\n    static __plugins: IRendererPlugins = {};\n\n    /**\n     * Collection of installed plugins. These are included by default in PIXI, but can be excluded\n     * by creating a custom build. Consult the README for more information about creating custom\n     * builds and excluding plugins.\n     * @member {object} plugins\n     * @readonly\n     * @property {PIXI.AccessibilityManager} accessibility Support tabbing interactive elements.\n     * @property {PIXI.CanvasExtract} extract Extract image data from renderer.\n     * @property {PIXI.InteractionManager} interaction Handles mouse, touch and pointer events.\n     * @property {PIXI.CanvasPrepare} prepare Pre-render display objects.\n     */\n\n    /**\n     * Use the {@link PIXI.extensions.add} API to register plugins.\n     * @deprecated since 6.5.0\n     * @param pluginName - The name of the plugin.\n     * @param ctor - The constructor function or class for the plugin.\n     */\n    static registerPlugin(pluginName: string, ctor: ICanvasRendererPluginConstructor): void\n    {\n        // #if _DEBUG\n        deprecation('6.5.0', 'CanvasRenderer.registerPlugin() has been deprecated, please use extensions.add() instead.');\n        // #endif\n        extensions.add({\n            name: pluginName,\n            type: ExtensionType.CanvasRendererPlugin,\n            ref: ctor,\n        });\n    }\n}\n\nextensions.handleByMap(ExtensionType.CanvasRendererPlugin, CanvasRenderer.__plugins);\n","import { BLEND_MODES } from '@pixi/constants';\nimport { canUseNewCanvasBlendModes } from './canUseNewCanvasBlendModes';\n\n/**\n * Maps blend combinations to Canvas.\n * @memberof PIXI\n * @function mapCanvasBlendModesToPixi\n * @private\n * @param {string[]} [array=[]] - The array to output into.\n * @returns {string[]} Mapped modes.\n */\n// TODO after upgrading to typeScript 4.6, replace `string[]` with `GlobalCompositeOperation[]`\nexport function mapCanvasBlendModesToPixi(array: string[] = []): string[]\n{\n    if (canUseNewCanvasBlendModes())\n    {\n        array[BLEND_MODES.NORMAL] = 'source-over';\n        array[BLEND_MODES.ADD] = 'lighter'; // IS THIS OK???\n        array[BLEND_MODES.MULTIPLY] = 'multiply';\n        array[BLEND_MODES.SCREEN] = 'screen';\n        array[BLEND_MODES.OVERLAY] = 'overlay';\n        array[BLEND_MODES.DARKEN] = 'darken';\n        array[BLEND_MODES.LIGHTEN] = 'lighten';\n        array[BLEND_MODES.COLOR_DODGE] = 'color-dodge';\n        array[BLEND_MODES.COLOR_BURN] = 'color-burn';\n        array[BLEND_MODES.HARD_LIGHT] = 'hard-light';\n        array[BLEND_MODES.SOFT_LIGHT] = 'soft-light';\n        array[BLEND_MODES.DIFFERENCE] = 'difference';\n        array[BLEND_MODES.EXCLUSION] = 'exclusion';\n        array[BLEND_MODES.HUE] = 'hue';\n        array[BLEND_MODES.SATURATION] = 'saturation';\n        array[BLEND_MODES.COLOR] = 'color';\n        array[BLEND_MODES.LUMINOSITY] = 'luminosity';\n    }\n    else\n    {\n        // this means that the browser does not support the cool new blend modes in canvas 'cough' ie 'cough'\n        array[BLEND_MODES.NORMAL] = 'source-over';\n        array[BLEND_MODES.ADD] = 'lighter'; // IS THIS OK???\n        array[BLEND_MODES.MULTIPLY] = 'source-over';\n        array[BLEND_MODES.SCREEN] = 'source-over';\n        array[BLEND_MODES.OVERLAY] = 'source-over';\n        array[BLEND_MODES.DARKEN] = 'source-over';\n        array[BLEND_MODES.LIGHTEN] = 'source-over';\n        array[BLEND_MODES.COLOR_DODGE] = 'source-over';\n        array[BLEND_MODES.COLOR_BURN] = 'source-over';\n        array[BLEND_MODES.HARD_LIGHT] = 'source-over';\n        array[BLEND_MODES.SOFT_LIGHT] = 'source-over';\n        array[BLEND_MODES.DIFFERENCE] = 'source-over';\n        array[BLEND_MODES.EXCLUSION] = 'source-over';\n        array[BLEND_MODES.HUE] = 'source-over';\n        array[BLEND_MODES.SATURATION] = 'source-over';\n        array[BLEND_MODES.COLOR] = 'source-over';\n        array[BLEND_MODES.LUMINOSITY] = 'source-over';\n    }\n    // not-premultiplied, only for webgl\n    array[BLEND_MODES.NORMAL_NPM] = array[BLEND_MODES.NORMAL];\n    array[BLEND_MODES.ADD_NPM] = array[BLEND_MODES.ADD];\n    array[BLEND_MODES.SCREEN_NPM] = array[BLEND_MODES.SCREEN];\n\n    // composite operations\n    array[BLEND_MODES.SRC_IN] = 'source-in';\n    array[BLEND_MODES.SRC_OUT] = 'source-out';\n    array[BLEND_MODES.SRC_ATOP] = 'source-atop';\n    array[BLEND_MODES.DST_OVER] = 'destination-over';\n    array[BLEND_MODES.DST_IN] = 'destination-in';\n    array[BLEND_MODES.DST_OUT] = 'destination-out';\n    array[BLEND_MODES.DST_ATOP] = 'destination-atop';\n    array[BLEND_MODES.XOR] = 'xor';\n\n    // SUBTRACT from flash, does not exist in canvas\n    array[BLEND_MODES.SUBTRACT] = 'source-over';\n\n    return array;\n}\n","import { hex2rgb, rgb2hex } from '@pixi/utils';\nimport { settings } from '@pixi/settings';\nimport { canUseNewCanvasBlendModes } from './utils/canUseNewCanvasBlendModes';\n\nimport type { Texture } from '@pixi/core';\n\n/**\n * Utility methods for Sprite/Texture tinting.\n *\n * Tinting with the CanvasRenderer involves creating a new canvas to use as a texture,\n * so be aware of the performance implications.\n * @namespace PIXI.canvasUtils\n * @memberof PIXI\n */\nexport const canvasUtils = {\n    canvas: null as HTMLCanvasElement,\n\n    /**\n     * Basically this method just needs a sprite and a color and tints the sprite with the given color.\n     * @memberof PIXI.canvasUtils\n     * @param {PIXI.Sprite} sprite - the sprite to tint\n     * @param sprite.texture\n     * @param {number} color - the color to use to tint the sprite with\n     * @returns {HTMLCanvasElement} The tinted canvas\n     */\n    getTintedCanvas: (sprite: { texture: Texture }, color: number): HTMLCanvasElement | HTMLImageElement =>\n    {\n        const texture = sprite.texture;\n\n        color = canvasUtils.roundColor(color);\n\n        const stringColor = `#${(`00000${(color | 0).toString(16)}`).slice(-6)}`;\n\n        texture.tintCache = texture.tintCache || {};\n\n        const cachedCanvas = texture.tintCache[stringColor];\n\n        let canvas: HTMLCanvasElement;\n\n        if (cachedCanvas)\n        {\n            if (cachedCanvas.tintId === texture._updateID)\n            {\n                return texture.tintCache[stringColor];\n            }\n\n            canvas = texture.tintCache[stringColor] as HTMLCanvasElement;\n        }\n        else\n        {\n            canvas = settings.ADAPTER.createCanvas();\n        }\n\n        canvasUtils.tintMethod(texture, color, canvas);\n\n        canvas.tintId = texture._updateID;\n\n        if (canvasUtils.convertTintToImage)\n        {\n            // is this better?\n            const tintImage = new Image();\n\n            tintImage.src = (canvas as HTMLCanvasElement).toDataURL();\n\n            texture.tintCache[stringColor] = tintImage;\n        }\n        else\n        {\n            texture.tintCache[stringColor] = canvas;\n        }\n\n        return canvas;\n    },\n\n    /**\n     * Basically this method just needs a sprite and a color and tints the sprite with the given color.\n     * @memberof PIXI.canvasUtils\n     * @param {PIXI.Texture} texture - the sprite to tint\n     * @param {number} color - the color to use to tint the sprite with\n     * @returns {HTMLCanvasElement} The tinted canvas\n     */\n    getTintedPattern: (texture: Texture, color: number): CanvasPattern =>\n    {\n        color = canvasUtils.roundColor(color);\n\n        const stringColor = `#${(`00000${(color | 0).toString(16)}`).slice(-6)}`;\n\n        texture.patternCache = texture.patternCache || {};\n\n        let pattern = texture.patternCache[stringColor];\n\n        if (pattern && pattern.tintId === texture._updateID)\n        {\n            return pattern;\n        }\n        if (!canvasUtils.canvas)\n        {\n            canvasUtils.canvas = settings.ADAPTER.createCanvas();\n        }\n        canvasUtils.tintMethod(texture, color, canvasUtils.canvas);\n        pattern = canvasUtils.canvas.getContext('2d').createPattern(canvasUtils.canvas, 'repeat');\n        pattern.tintId = texture._updateID;\n        texture.patternCache[stringColor] = pattern;\n\n        return pattern;\n    },\n\n    /**\n     * Tint a texture using the 'multiply' operation.\n     * @memberof PIXI.canvasUtils\n     * @param {PIXI.Texture} texture - the texture to tint\n     * @param {number} color - the color to use to tint the sprite with\n     * @param {HTMLCanvasElement} canvas - the current canvas\n     */\n    tintWithMultiply: (texture: Texture, color: number, canvas: HTMLCanvasElement): void =>\n    {\n        const context = canvas.getContext('2d');\n        const crop = texture._frame.clone();\n        const resolution = texture.baseTexture.resolution;\n\n        crop.x *= resolution;\n        crop.y *= resolution;\n        crop.width *= resolution;\n        crop.height *= resolution;\n\n        canvas.width = Math.ceil(crop.width);\n        canvas.height = Math.ceil(crop.height);\n\n        context.save();\n        context.fillStyle = `#${(`00000${(color | 0).toString(16)}`).slice(-6)}`;\n\n        context.fillRect(0, 0, crop.width, crop.height);\n\n        context.globalCompositeOperation = 'multiply';\n\n        const source = texture.baseTexture.getDrawableSource();\n\n        context.drawImage(\n            source,\n            crop.x,\n            crop.y,\n            crop.width,\n            crop.height,\n            0,\n            0,\n            crop.width,\n            crop.height\n        );\n\n        context.globalCompositeOperation = 'destination-atop';\n\n        context.drawImage(\n            source,\n            crop.x,\n            crop.y,\n            crop.width,\n            crop.height,\n            0,\n            0,\n            crop.width,\n            crop.height\n        );\n        context.restore();\n    },\n\n    /**\n     * Tint a texture using the 'overlay' operation.\n     * @memberof PIXI.canvasUtils\n     * @param {PIXI.Texture} texture - the texture to tint\n     * @param {number} color - the color to use to tint the sprite with\n     * @param {HTMLCanvasElement} canvas - the current canvas\n     */\n    tintWithOverlay: (texture: Texture, color: number, canvas: HTMLCanvasElement): void =>\n    {\n        const context = canvas.getContext('2d');\n        const crop = texture._frame.clone();\n        const resolution = texture.baseTexture.resolution;\n\n        crop.x *= resolution;\n        crop.y *= resolution;\n        crop.width *= resolution;\n        crop.height *= resolution;\n\n        canvas.width = Math.ceil(crop.width);\n        canvas.height = Math.ceil(crop.height);\n\n        context.save();\n        context.globalCompositeOperation = 'copy';\n        context.fillStyle = `#${(`00000${(color | 0).toString(16)}`).slice(-6)}`;\n        context.fillRect(0, 0, crop.width, crop.height);\n\n        context.globalCompositeOperation = 'destination-atop';\n        context.drawImage(\n            texture.baseTexture.getDrawableSource(),\n            crop.x,\n            crop.y,\n            crop.width,\n            crop.height,\n            0,\n            0,\n            crop.width,\n            crop.height\n        );\n\n        // context.globalCompositeOperation = 'copy';\n        context.restore();\n    },\n\n    /**\n     * Tint a texture pixel per pixel.\n     * @memberof PIXI.canvasUtils\n     * @param {PIXI.Texture} texture - the texture to tint\n     * @param {number} color - the color to use to tint the sprite with\n     * @param {HTMLCanvasElement} canvas - the current canvas\n     */\n    tintWithPerPixel: (texture: Texture, color: number, canvas: HTMLCanvasElement): void =>\n    {\n        const context = canvas.getContext('2d');\n        const crop = texture._frame.clone();\n        const resolution = texture.baseTexture.resolution;\n\n        crop.x *= resolution;\n        crop.y *= resolution;\n        crop.width *= resolution;\n        crop.height *= resolution;\n\n        canvas.width = Math.ceil(crop.width);\n        canvas.height = Math.ceil(crop.height);\n\n        context.save();\n        context.globalCompositeOperation = 'copy';\n        context.drawImage(\n            texture.baseTexture.getDrawableSource(),\n            crop.x,\n            crop.y,\n            crop.width,\n            crop.height,\n            0,\n            0,\n            crop.width,\n            crop.height\n        );\n        context.restore();\n\n        const rgbValues = hex2rgb(color);\n        const r = rgbValues[0];\n        const g = rgbValues[1];\n        const b = rgbValues[2];\n\n        const pixelData = context.getImageData(0, 0, crop.width, crop.height);\n\n        const pixels = pixelData.data;\n\n        for (let i = 0; i < pixels.length; i += 4)\n        {\n            pixels[i + 0] *= r;\n            pixels[i + 1] *= g;\n            pixels[i + 2] *= b;\n        }\n\n        context.putImageData(pixelData, 0, 0);\n    },\n\n    /**\n     * Rounds the specified color according to the canvasUtils.cacheStepsPerColorChannel.\n     * @memberof PIXI.canvasUtils\n     * @param {number} color - the color to round, should be a hex color\n     * @returns {number} The rounded color.\n     */\n    roundColor: (color: number): number =>\n    {\n        const step = canvasUtils.cacheStepsPerColorChannel;\n\n        const rgbValues = hex2rgb(color);\n\n        rgbValues[0] = Math.min(255, (rgbValues[0] / step) * step);\n        rgbValues[1] = Math.min(255, (rgbValues[1] / step) * step);\n        rgbValues[2] = Math.min(255, (rgbValues[2] / step) * step);\n\n        return rgb2hex(rgbValues);\n    },\n\n    /**\n     * Number of steps which will be used as a cap when rounding colors.\n     * @memberof PIXI.canvasUtils\n     * @type {number}\n     */\n    cacheStepsPerColorChannel: 8,\n\n    /**\n     * Tint cache boolean flag.\n     * @memberof PIXI.canvasUtils\n     * @type {boolean}\n     */\n    convertTintToImage: false,\n\n    /**\n     * Whether or not the Canvas BlendModes are supported, consequently the ability to tint using the multiply method.\n     * @memberof PIXI.canvasUtils\n     * @type {boolean}\n     */\n    canUseMultiply: canUseNewCanvasBlendModes(),\n\n    /**\n     * The tinting method that will be used.\n     * @memberof PIXI.canvasUtils\n     * @type {Function}\n     */\n    tintMethod: null as (texture: Texture, color: number, canvas: HTMLCanvasElement) => void,\n};\n\ncanvasUtils.tintMethod = canvasUtils.canUseMultiply ? canvasUtils.tintWithMultiply : canvasUtils.tintWithPerPixel;\n","import { Renderer } from '@pixi/core';\nimport { CanvasRenderer } from './CanvasRenderer';\n\nimport type { AbstractRenderer, IRendererOptionsAuto } from '@pixi/core';\n\n// Reference to Renderer.create static function\nconst parentCreate = Renderer.create;\n\n/**\n * Override the Renderer.create to fallback to use CanvasRenderer.\n * Also supports forceCanvas option with Application or autoDetectRenderer.\n * @param options\n * @private\n */\nRenderer.create = function create(options: IRendererOptionsAuto): AbstractRenderer\n{\n    const forceCanvas = options && options.forceCanvas;\n\n    if (!forceCanvas)\n    {\n        try\n        {\n            return parentCreate(options);\n        }\n        catch (err)\n        {\n            // swallow WebGL-unsupported error\n        }\n    }\n\n    return new CanvasRenderer(options);\n};\n","import { BaseTexture, BaseRenderTexture, Texture } from '@pixi/core';\n\n/**\n * Get the drawable source, such as HTMLCanvasElement or HTMLImageElement suitable\n * for rendering with CanvasRenderer. Provided by **@pixi/canvas-renderer** package.\n * @method getDrawableSource\n * @memberof PIXI.BaseTexture#\n * @returns {PIXI.ICanvasImageSource} Source to render with CanvasRenderer\n */\nBaseTexture.prototype.getDrawableSource = function getDrawableSource(): CanvasImageSource\n{\n    const resource = this.resource as any;\n\n    return resource ? (resource.bitmap || resource.source) : null;\n};\n\n/**\n * A reference to the canvas render target (we only need one as this can be shared across renderers)\n * @protected\n * @member {PIXI.utils.CanvasRenderTarget} _canvasRenderTarget\n * @memberof PIXI.BaseRenderTexture#\n */\n\nBaseRenderTexture.prototype._canvasRenderTarget = null;\n\nTexture.prototype.patternCache = null;\n\nTexture.prototype.tintCache = null;\n","import type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType, Texture } from '@pixi/core';\nimport { DRAW_MODES } from '@pixi/constants';\nimport { canvasUtils } from '@pixi/canvas-renderer';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\nimport type { Mesh } from '@pixi/mesh';\n\n/**\n * Renderer dedicated to meshes.\n * @class\n * @protected\n * @memberof PIXI\n */\nexport class CanvasMeshRenderer\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'mesh',\n        type: ExtensionType.CanvasRendererPlugin,\n    };\n\n    /** A reference to the current renderer */\n    public renderer: CanvasRenderer;\n\n    /** @param renderer - A reference to the current renderer */\n    constructor(renderer: CanvasRenderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * Renders the Mesh\n     * @param mesh - the Mesh to render\n     */\n    public render(mesh: Mesh): void\n    {\n        const renderer = this.renderer;\n        const transform = mesh.worldTransform;\n\n        renderer.context.globalAlpha = mesh.worldAlpha;\n        renderer.setBlendMode(mesh.blendMode);\n        renderer.setContextTransform(transform, mesh.roundPixels);\n\n        if (mesh.drawMode !== DRAW_MODES.TRIANGLES)\n        {\n            this._renderTriangleMesh(mesh);\n        }\n        else\n        {\n            this._renderTriangles(mesh);\n        }\n    }\n\n    /**\n     * Draws the object in Triangle Mesh mode\n     * @private\n     * @param mesh - the Mesh to render\n     */\n    private _renderTriangleMesh(mesh: Mesh): void\n    {\n        // draw triangles!!\n        const length = mesh.geometry.buffers[0].data.length;\n\n        for (let i = 0; i < length - 2; i++)\n        {\n            // draw some triangles!\n            const index = i * 2;\n\n            this._renderDrawTriangle(mesh, index, (index + 2), (index + 4));\n        }\n    }\n\n    /**\n     * Draws the object in triangle mode using canvas\n     * @private\n     * @param mesh - the current mesh\n     */\n    private _renderTriangles(mesh: Mesh): void\n    {\n        // draw triangles!!\n        const indices = mesh.geometry.getIndex().data;\n        const length = indices.length;\n\n        for (let i = 0; i < length; i += 3)\n        {\n            // draw some triangles!\n            const index0 = indices[i] * 2;\n            const index1 = indices[i + 1] * 2;\n            const index2 = indices[i + 2] * 2;\n\n            this._renderDrawTriangle(mesh, index0, index1, index2);\n        }\n    }\n\n    /**\n     * Draws one of the triangles that from the Mesh\n     * @private\n     * @param mesh - the current mesh\n     * @param index0 - the index of the first vertex\n     * @param index1 - the index of the second vertex\n     * @param index2 - the index of the third vertex\n     */\n    private _renderDrawTriangle(mesh: Mesh, index0: number, index1: number, index2: number): void\n    {\n        const context = this.renderer.context;\n        const vertices = mesh.geometry.buffers[0].data;\n        const { uvs, texture } = mesh;\n\n        if (!texture.valid)\n        {\n            return;\n        }\n        const isTinted = mesh.tint !== 0xFFFFFF;\n        const base = texture.baseTexture;\n        const textureWidth = base.width;\n        const textureHeight = base.height;\n\n        if (isTinted)\n        {\n            if (mesh._cachedTint !== mesh.tint)\n            {\n                mesh._cachedTint = mesh.tint;\n                mesh._cachedTexture = mesh._cachedTexture || new Texture(base);\n                mesh._tintedCanvas = canvasUtils.getTintedCanvas(\n                    { texture: mesh._cachedTexture },\n                    mesh.tint\n                ) as HTMLCanvasElement;\n            }\n        }\n\n        const textureSource = isTinted ? mesh._tintedCanvas : base.getDrawableSource();\n\n        const u0 = uvs[index0] * base.width;\n        const u1 = uvs[index1] * base.width;\n        const u2 = uvs[index2] * base.width;\n        const v0 = uvs[index0 + 1] * base.height;\n        const v1 = uvs[index1 + 1] * base.height;\n        const v2 = uvs[index2 + 1] * base.height;\n\n        let x0 = vertices[index0];\n        let x1 = vertices[index1];\n        let x2 = vertices[index2];\n        let y0 = vertices[index0 + 1];\n        let y1 = vertices[index1 + 1];\n        let y2 = vertices[index2 + 1];\n\n        const screenPadding = mesh.canvasPadding / this.renderer.resolution;\n\n        if (screenPadding > 0)\n        {\n            const { a, b, c, d } = mesh.worldTransform;\n\n            const centerX = (x0 + x1 + x2) / 3;\n            const centerY = (y0 + y1 + y2) / 3;\n\n            let normX = x0 - centerX;\n            let normY = y0 - centerY;\n\n            // Transform to screen space and calculate the distance\n            let screenX = (a * normX) + (c * normY);\n            let screenY = (b * normX) + (d * normY);\n            let screenDist = Math.sqrt((screenX * screenX) + (screenY * screenY));\n\n            // Factor by which to scale in order to add padding equal to screenPadding\n            let paddingFactor = 1 + (screenPadding / screenDist);\n\n            x0 = centerX + (normX * paddingFactor);\n            y0 = centerY + (normY * paddingFactor);\n\n            normX = x1 - centerX;\n            normY = y1 - centerY;\n\n            screenX = (a * normX) + (c * normY);\n            screenY = (b * normX) + (d * normY);\n            screenDist = Math.sqrt((screenX * screenX) + (screenY * screenY));\n\n            paddingFactor = 1 + (screenPadding / screenDist);\n\n            x1 = centerX + (normX * paddingFactor);\n            y1 = centerY + (normY * paddingFactor);\n\n            normX = x2 - centerX;\n            normY = y2 - centerY;\n\n            screenX = (a * normX) + (c * normY);\n            screenY = (b * normX) + (d * normY);\n            screenDist = Math.sqrt((screenX * screenX) + (screenY * screenY));\n\n            paddingFactor = 1 + (screenPadding / screenDist);\n\n            x2 = centerX + (normX * paddingFactor);\n            y2 = centerY + (normY * paddingFactor);\n        }\n\n        context.save();\n        context.beginPath();\n\n        context.moveTo(x0, y0);\n        context.lineTo(x1, y1);\n        context.lineTo(x2, y2);\n\n        context.closePath();\n\n        context.clip();\n\n        // Compute matrix transform\n        const delta = (u0 * v1) + (v0 * u2) + (u1 * v2) - (v1 * u2) - (v0 * u1) - (u0 * v2);\n        const deltaA = (x0 * v1) + (v0 * x2) + (x1 * v2) - (v1 * x2) - (v0 * x1) - (x0 * v2);\n        const deltaB = (u0 * x1) + (x0 * u2) + (u1 * x2) - (x1 * u2) - (x0 * u1) - (u0 * x2);\n        const deltaC = (u0 * v1 * x2) + (v0 * x1 * u2) + (x0 * u1 * v2) - (x0 * v1 * u2) - (v0 * u1 * x2) - (u0 * x1 * v2);\n        const deltaD = (y0 * v1) + (v0 * y2) + (y1 * v2) - (v1 * y2) - (v0 * y1) - (y0 * v2);\n        const deltaE = (u0 * y1) + (y0 * u2) + (u1 * y2) - (y1 * u2) - (y0 * u1) - (u0 * y2);\n        const deltaF = (u0 * v1 * y2) + (v0 * y1 * u2) + (y0 * u1 * v2) - (y0 * v1 * u2) - (v0 * u1 * y2) - (u0 * y1 * v2);\n\n        context.transform(\n            deltaA / delta,\n            deltaD / delta,\n            deltaB / delta,\n            deltaE / delta,\n            deltaC / delta,\n            deltaF / delta\n        );\n\n        context.drawImage(\n            textureSource,\n            0,\n            0,\n            textureWidth * base.resolution,\n            textureHeight * base.resolution,\n            0,\n            0,\n            textureWidth,\n            textureHeight\n        );\n\n        context.restore();\n        this.renderer.invalidateBlendMode();\n    }\n\n    /**\n     * Renders a flat Mesh\n     * @private\n     * @param mesh - The Mesh to render\n     */\n    renderMeshFlat(mesh: Mesh): void\n    {\n        const context = this.renderer.context;\n        const vertices = mesh.geometry.getBuffer('aVertexPosition').data;\n        const length = vertices.length / 2;\n\n        // this.count++;\n\n        context.beginPath();\n\n        for (let i = 1; i < length - 2; ++i)\n        {\n            // draw some triangles!\n            const index = i * 2;\n\n            const x0 = vertices[index];\n            const y0 = vertices[index + 1];\n\n            const x1 = vertices[index + 2];\n            const y1 = vertices[index + 3];\n\n            const x2 = vertices[index + 4];\n            const y2 = vertices[index + 5];\n\n            context.moveTo(x0, y0);\n            context.lineTo(x1, y1);\n            context.lineTo(x2, y2);\n        }\n\n        context.fillStyle = '#FF0000';\n        context.fill();\n        context.closePath();\n    }\n\n    /** destroy the renderer */\n    public destroy(): void\n    {\n        this.renderer = null;\n    }\n}\n","import { settings } from '@pixi/settings';\n\n/**\n * Default `canvasPadding` for canvas-based Mesh rendering.\n * @see PIXI.Mesh2d#canvasPadding\n * @static\n * @memberof PIXI.settings\n * @member {number}\n * @default 0\n */\nsettings.MESH_CANVAS_PADDING = 0;\n\nexport { settings };\n","import { MeshMaterial } from '@pixi/mesh';\n\nimport type { Mesh } from '@pixi/mesh';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the mesh using the Canvas renderer\n * @protected\n * @method render\n * @memberof PIXI.MeshMaterial#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.\n * @param {PIXI.Mesh} mesh - Mesh to render.\n */\nMeshMaterial.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer, mesh: Mesh): void\n{\n    renderer.plugins.mesh.render(mesh);\n};\n","import { canvasUtils } from '@pixi/canvas-renderer';\nimport { NineSlicePlane } from '@pixi/mesh-extras';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Cached tint value so we can tell when the tint is changed.\n * @memberof PIXI.NineSlicePlane#\n * @member {number} _cachedTint\n * @protected\n */\nNineSlicePlane.prototype._cachedTint = 0xFFFFFF;\n\n/**\n * Cached tinted texture.\n * @memberof PIXI.NineSlicePlane#\n * @member {HTMLCanvasElement} _tintedCanvas\n * @protected\n */\nNineSlicePlane.prototype._tintedCanvas = null;\n\n/**\n * Temporary storage for canvas source coords\n * @memberof PIXI.NineSlicePlane#\n * @member {number[]} _canvasUvs\n * @private\n */\nNineSlicePlane.prototype._canvasUvs = null;\n\n/**\n * Renders the object using the Canvas renderer\n * @private\n * @method _renderCanvas\n * @memberof PIXI.NineSlicePlane#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer to render with.\n */\nNineSlicePlane.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    const context = renderer.context;\n    const transform = this.worldTransform;\n    const isTinted = this.tint !== 0xFFFFFF;\n    const texture = this.texture;\n\n    if (!texture.valid)\n    {\n        return;\n    }\n\n    // Work out tinting\n    if (isTinted)\n    {\n        if (this._cachedTint !== this.tint)\n        {\n            // Tint has changed, need to update the tinted texture and use that instead\n\n            this._cachedTint = this.tint;\n\n            this._tintedCanvas = canvasUtils.getTintedCanvas(this, this.tint) as HTMLCanvasElement;\n        }\n    }\n\n    const textureSource = !isTinted ? texture.baseTexture.getDrawableSource() : this._tintedCanvas;\n\n    if (!this._canvasUvs)\n    {\n        this._canvasUvs = [0, 0, 0, 0, 0, 0, 0, 0];\n    }\n\n    const vertices = this.vertices;\n    const uvs = this._canvasUvs;\n    const u0 = isTinted ? 0 : texture.frame.x;\n    const v0 = isTinted ? 0 : texture.frame.y;\n    const u1 = u0 + texture.frame.width;\n    const v1 = v0 + texture.frame.height;\n\n    uvs[0] = u0;\n    uvs[1] = u0 + this._leftWidth;\n    uvs[2] = u1 - this._rightWidth;\n    uvs[3] = u1;\n    uvs[4] = v0;\n    uvs[5] = v0 + this._topHeight;\n    uvs[6] = v1 - this._bottomHeight;\n    uvs[7] = v1;\n\n    for (let i = 0; i < 8; i++)\n    {\n        uvs[i] *= texture.baseTexture.resolution;\n    }\n\n    context.globalAlpha = this.worldAlpha;\n    renderer.setBlendMode(this.blendMode);\n    renderer.setContextTransform(transform, this.roundPixels);\n\n    for (let row = 0; row < 3; row++)\n    {\n        for (let col = 0; col < 3; col++)\n        {\n            const ind = (col * 2) + (row * 8);\n            const sw = Math.max(1, uvs[col + 1] - uvs[col]);\n            const sh = Math.max(1, uvs[row + 5] - uvs[row + 4]);\n            const dw = Math.max(1, vertices[ind + 10] - vertices[ind]);\n            const dh = Math.max(1, vertices[ind + 11] - vertices[ind + 1]);\n\n            context.drawImage(textureSource, uvs[col], uvs[row + 4], sw, sh,\n                vertices[ind], vertices[ind + 1], dw, dh);\n        }\n    }\n};\n","import { Mesh } from '@pixi/mesh';\nimport { settings } from './settings';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\nlet warned = false;\n\n/**\n * Cached tint value so we can tell when the tint is changed.\n * @memberof PIXI.Mesh#\n * @member {number} _cachedTint\n * @protected\n */\nMesh.prototype._cachedTint = 0xFFFFFF;\n\n/**\n * Cached tinted texture.\n * @memberof PIXI.Mesh#\n * @member {HTMLCanvasElement} _tintedCanvas\n * @protected\n */\nMesh.prototype._tintedCanvas = null;\n\n/**\n * The cache texture is used to generate `_tintedCanvas`.\n * @memberof PIXI.Mesh#\n * @member {PIXI.Texture} _cachedTexture\n * @protected\n */\nMesh.prototype._cachedTexture = null;\n\n/**\n * Renders the object using the Canvas renderer\n * @private\n * @method _renderCanvas\n * @memberof PIXI.Mesh#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.\n */\nMesh.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    if (this.shader.uvMatrix)\n    {\n        this.shader.uvMatrix.update();\n        this.calculateUvs();\n    }\n\n    if (this.material._renderCanvas)\n    {\n        this.material._renderCanvas(renderer, this);\n    }\n    else if (!warned)\n    {\n        warned = true;\n        if (globalThis.console)\n        {\n            console.warn('Mesh with custom shaders are not supported in CanvasRenderer.');\n        }\n    }\n};\n\n// IMPORTANT: Please do NOT use this as a precedent to use `settings` after the object is created\n// this was merely created to completely decouple canvas from the base Mesh class and we are\n// unable to add `canvasPadding` in the constructor anymore, as the case was for PixiJS v4.\n\n/**\n * Internal variable for `canvasPadding`.\n * @private\n * @memberof PIXI.Mesh\n * @member {number}\n * @default null\n */\nMesh.prototype._canvasPadding = null;\n\n/**\n * Triangles in canvas mode are automatically antialiased, use this value to force triangles\n * to overlap a bit with each other. To set the global default, set {@link PIXI.settings.MESH_CANVAS_PADDING}\n * @see PIXI.settings.MESH_CANVAS_PADDING\n * @member {number} canvasPadding\n * @memberof PIXI.SimpleMesh#\n * @default 0\n */\nObject.defineProperty(Mesh.prototype, 'canvasPadding', {\n    get()\n    {\n        return this._canvasPadding !== null ? this._canvasPadding : settings.MESH_CANVAS_PADDING;\n    },\n    set(value)\n    {\n        this._canvasPadding = value;\n    },\n});\n","import { SimpleMesh } from '@pixi/mesh-extras';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the object using the Canvas renderer\n * @private\n * @method _renderCanvas\n * @memberof PIXI.Mesh#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.\n */\nSimpleMesh.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    if (this.autoUpdate)\n    {\n        this.geometry.getBuffer('aVertexPosition').update();\n    }\n\n    if (this.shader.update)\n    {\n        this.shader.update();\n    }\n\n    this.calculateUvs();\n\n    this.material._renderCanvas(renderer, this);\n};\n","import { SimpleRope } from '@pixi/mesh-extras';\n\nimport type { RopeGeometry } from '@pixi/mesh-extras';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the object using the Canvas renderer\n * @protected\n * @method _renderCanvas\n * @memberof PIXI.Mesh#\n * @param {PIXI.CanvasRenderer} renderer - The canvas renderer.\n */\nSimpleRope.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    if (this.autoUpdate\n        || (this.geometry as RopeGeometry)._width !== this.shader.texture.height)\n    {\n        (this.geometry as RopeGeometry)._width = this.shader.texture.height;\n        (this.geometry as RopeGeometry).update();\n    }\n\n    if (this.shader.update)\n    {\n        this.shader.update();\n    }\n\n    this.calculateUvs();\n\n    this.material._renderCanvas(renderer, this);\n};\n","/**\n * Utilities for polygon\n * @class\n * @private\n */\nexport class PolygonUtils\n{\n    /**\n     * Calculate points of an offset polygon\n     * @see {@link http://csharphelper.com/blog/2016/01/enlarge-a-polygon-in-c/}\n     * @private\n     * @param {number[]} points - polygon coordinates\n     * @param {number} offset\n     * @returns {number[]} - offset points\n     */\n    static offsetPolygon(points: number[], offset: number): number[]\n    {\n        const offsetPoints: number[] = [];\n        const length: number = points.length;\n\n        offset = PolygonUtils.isPolygonClockwise(points) ? offset : -1 * offset;\n\n        for (let j = 0; j < length; j += 2)\n        {\n            // Find location for the points before and after j\n            let i = (j - 2);\n\n            if (i < 0)\n            {\n                i += length;\n            }\n\n            const k = (j + 2) % length;\n\n            // Move the points by the offset\n            let v1x = points[j] - points[i];\n            let v1y = points[j + 1] - points[i + 1];\n            let len = Math.sqrt((v1x * v1x) + (v1y * v1y));\n\n            v1x /= len;\n            v1y /= len;\n            v1x *= offset;\n            v1y *= offset;\n\n            const norm1x = -v1y;\n            const norm1y = v1x;\n\n            const pij1 = [points[i] + norm1x, points[i + 1] + norm1y];\n            const pij2 = [points[j] + norm1x, points[j + 1] + norm1y];\n\n            let v2x = points[k] - points[j];\n            let v2y = points[k + 1] - points[j + 1];\n\n            len = Math.sqrt((v2x * v2x) + (v2y * v2y));\n\n            v2x /= len;\n            v2y /= len;\n            v2x *= offset;\n            v2y *= offset;\n\n            const norm2x = -v2y;\n            const norm2y = v2x;\n\n            const pjk1 = [points[j] + norm2x, points[j + 1] + norm2y];\n            const pjk2 = [points[k] + norm2x, points[k + 1] + norm2y];\n\n            // Find where the shifted lines ij and jk intersect.\n            const intersectPoint = PolygonUtils\n                .findIntersection(pij1[0], pij1[1], pij2[0], pij2[1], pjk1[0], pjk1[1], pjk2[0], pjk2[1]);\n\n            if (intersectPoint)\n            {\n                offsetPoints.push(...intersectPoint);\n            }\n        }\n\n        return offsetPoints;\n    }\n\n    /**\n     * Determine the intersection point of two line segments\n     * @see {@link here http://paulbourke.net/geometry/pointlineplane/}\n     * @private\n     * @param {number} x1 - x-coordinate of start point at first line\n     * @param {number} y1 - y-coordinate of start point at first line\n     * @param {number} x2 - x-coordinate of end point at first line\n     * @param {number} y2 - y-coordinate of end point at first line\n     * @param {number} x3 - x-coordinate of start point at second line\n     * @param {number} y3 - y-coordinate of start point at second line\n     * @param {number} x4 - x-coordinate of end point at second line\n     * @param {number} y4 - y-coordinate of end point at second line\n     * @returns {[number, number] | null} - [x, y] coordinates of intersection\n     */\n    static findIntersection(\n        x1: number, y1: number, x2: number, y2: number,\n        x3: number, y3: number, x4: number, y4: number\n    ): [number, number] | null\n    {\n        const denominator = ((y4 - y3) * (x2 - x1)) - ((x4 - x3) * (y2 - y1));\n        const numeratorA = ((x4 - x3) * (y1 - y3)) - ((y4 - y3) * (x1 - x3));\n        const numeratorB = ((x2 - x1) * (y1 - y3)) - ((y2 - y1) * (x1 - x3));\n\n        // lines are parallel\n        if (denominator === 0)\n        {\n            // lines are coincident\n            if (numeratorA === 0 && numeratorB === 0)\n            {\n                return [(x1 + x2) / 2, (y1 + y2) / 2];\n            }\n\n            return null;\n        }\n\n        const uA = numeratorA / denominator;\n\n        return [x1 + (uA * (x2 - x1)), y1 + (uA * (y2 - y1))];\n    }\n\n    /**\n     * Determine polygon are clockwise or counterclockwise\n     * @see {@link https://stackoverflow.com/questions/1165647}\n     * @private\n     * @param {number[]} polygon - polygon coordinates\n     * @returns {boolean} - true if polygon is clockwise\n     */\n    static isPolygonClockwise(polygon: number[]): boolean\n    {\n        let sum = 0;\n\n        for (let i = 0, j = polygon.length - 2; i < polygon.length; j = i, i += 2)\n        {\n            sum += (polygon[i] - polygon[j]) * (polygon[i + 1] + polygon[j + 1]);\n        }\n\n        return sum > 0;\n    }\n}\n","import { Graphics } from '@pixi/graphics';\nimport { CanvasRenderer } from '@pixi/canvas-renderer';\nimport { RenderTexture, Texture } from '@pixi/core';\nimport { Matrix } from '@pixi/math';\n\nimport type { SCALE_MODES } from '@pixi/constants';\nimport type { BaseRenderTexture } from '@pixi/core';\n\nlet canvasRenderer: CanvasRenderer;\nconst tempMatrix = new Matrix();\n\n/**\n * Generates a canvas texture. Only available with **pixi.js-legacy** bundle\n * or the **@pixi/canvas-graphics** package.\n * @method generateCanvasTexture\n * @memberof PIXI.Graphics#\n * @param {PIXI.SCALE_MODES} [scaleMode] - The scale mode of the texture.\n * @param {number} resolution - The resolution of the texture.\n * @returns {PIXI.Texture} The new texture.\n */\nGraphics.prototype.generateCanvasTexture = function generateCanvasTexture(scaleMode?: SCALE_MODES, resolution = 1): Texture\n{\n    const bounds = this.getLocalBounds();\n\n    const canvasBuffer = RenderTexture.create({\n        width: bounds.width,\n        height: bounds.height,\n        scaleMode,\n        resolution,\n    });\n\n    if (!canvasRenderer)\n    {\n        canvasRenderer = new CanvasRenderer();\n    }\n\n    this.transform.updateLocalTransform();\n    this.transform.localTransform.copyTo(tempMatrix);\n\n    tempMatrix.invert();\n\n    tempMatrix.tx -= bounds.x;\n    tempMatrix.ty -= bounds.y;\n\n    canvasRenderer.render(this, { renderTexture: canvasBuffer, clear: true, transform: tempMatrix });\n\n    const texture = Texture.from((canvasBuffer.baseTexture as BaseRenderTexture)._canvasRenderTarget.canvas, {\n        scaleMode,\n    });\n\n    texture.baseTexture.setResolution(resolution);\n\n    return texture;\n};\n\nGraphics.prototype.cachedGraphicsData = [];\n\n/**\n * Renders the object using the Canvas renderer\n * @method _renderCanvas\n * @memberof PIXI.Graphics#\n * @private\n * @param {PIXI.CanvasRenderer} renderer - The renderer\n */\nGraphics.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    if (this.isMask === true)\n    {\n        return;\n    }\n\n    this.finishPoly();\n    renderer.plugins.graphics.render(this);\n};\n","import type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType, Texture } from '@pixi/core';\nimport { SHAPES, Matrix } from '@pixi/math';\nimport { canvasUtils } from '@pixi/canvas-renderer';\nimport type { CanvasRenderer, CrossPlatformCanvasRenderingContext2D } from '@pixi/canvas-renderer';\nimport type { FillStyle, Graphics, GraphicsData, LineStyle } from '@pixi/graphics';\nimport type { Circle, Ellipse, Polygon, Rectangle, RoundedRectangle } from '@pixi/math';\nimport { PolygonUtils } from './utils/PolygonUtils';\n\n/*\n * @author Mat Groves\n *\n * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/\n * for creating the original PixiJS version!\n * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they\n * now share 4 bytes on the vertex buffer\n *\n * Heavily inspired by LibGDX's CanvasGraphicsRenderer:\n * https://github.com/libgdx/libgdx/blob/1.0.0/gdx/src/com/badlogic/gdx/graphics/glutils/ShapeRenderer.java\n */\n\n/**\n * Renderer dedicated to drawing and batching graphics objects.\n * @class\n * @protected\n * @memberof PIXI\n */\nexport class CanvasGraphicsRenderer\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'graphics',\n        type: ExtensionType.CanvasRendererPlugin,\n    };\n\n    /** A reference to the current renderer */\n    public renderer: CanvasRenderer;\n    private _svgMatrix: DOMMatrix | boolean = null;\n    private _tempMatrix: Matrix = new Matrix();\n\n    /**\n     * @param renderer - A reference to the current renderer.\n     */\n    constructor(renderer: CanvasRenderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * calculates fill/stroke style for canvas\n     * @private\n     * @param style - A graphics {@link PIXI.FILL_STYLE} where if `texture` is specified then a tinted CanvasPattern\n     * will be used for the fill.stroke\n     * @param tint - color to set the fill/stroke too.\n     */\n    private _calcCanvasStyle(style: FillStyle, tint: number): string | CanvasPattern\n    {\n        let res;\n\n        if (style.texture && style.texture.baseTexture !== Texture.WHITE.baseTexture)\n        {\n            if (style.texture.valid)\n            {\n                res = canvasUtils.getTintedPattern(style.texture, tint);\n                this.setPatternTransform(res, style.matrix || Matrix.IDENTITY);\n            }\n            else\n            {\n                res = '#808080';\n            }\n        }\n        else\n        {\n            res = `#${(`00000${(tint | 0).toString(16)}`).slice(-6)}`;\n        }\n\n        return res;\n    }\n\n    /**\n     * Renders a Graphics object to a canvas.\n     * @param graphics - the actual graphics object to render\n     */\n    public render(graphics: Graphics): void\n    {\n        const renderer = this.renderer;\n        const context = renderer.context;\n        const worldAlpha = graphics.worldAlpha;\n        const transform = graphics.transform.worldTransform;\n\n        renderer.setContextTransform(transform);\n        renderer.setBlendMode(graphics.blendMode);\n\n        const graphicsData = graphics.geometry.graphicsData;\n\n        let contextFillStyle;\n        let contextStrokeStyle;\n\n        const tintR = ((graphics.tint >> 16) & 0xFF) / 255;\n        const tintG = ((graphics.tint >> 8) & 0xFF) / 255;\n        const tintB = (graphics.tint & 0xFF) / 255;\n\n        for (let i = 0; i < graphicsData.length; i++)\n        {\n            const data = graphicsData[i];\n            const shape = data.shape;\n            const fillStyle = data.fillStyle;\n            const lineStyle = data.lineStyle;\n\n            const fillColor = data.fillStyle.color | 0;\n            const lineColor = data.lineStyle.color | 0;\n\n            if (data.matrix)\n            {\n                renderer.setContextTransform(transform.copyTo(this._tempMatrix).append(data.matrix));\n            }\n\n            if (fillStyle.visible)\n            {\n                const fillTint = (\n                    (((fillColor >> 16) & 0xFF) / 255 * tintR * 255 << 16)\n                    + (((fillColor >> 8) & 0xFF) / 255 * tintG * 255 << 8)\n                    + (((fillColor & 0xFF) / 255) * tintB * 255)\n                );\n\n                contextFillStyle = this._calcCanvasStyle(fillStyle, fillTint);\n            }\n            if (lineStyle.visible)\n            {\n                const lineTint = (\n                    (((lineColor >> 16) & 0xFF) / 255 * tintR * 255 << 16)\n                    + (((lineColor >> 8) & 0xFF) / 255 * tintG * 255 << 8)\n                    + (((lineColor & 0xFF) / 255) * tintB * 255)\n                );\n\n                contextStrokeStyle = this._calcCanvasStyle(lineStyle, lineTint);\n            }\n\n            context.lineWidth = lineStyle.width;\n            context.lineCap = lineStyle.cap;\n            context.lineJoin = lineStyle.join;\n            context.miterLimit = lineStyle.miterLimit;\n\n            if (data.type === SHAPES.POLY)\n            {\n                context.beginPath();\n\n                const tempShape = shape as Polygon;\n                let points = tempShape.points;\n                const holes = data.holes;\n                let outerArea;\n                let innerArea;\n                let px;\n                let py;\n                let holesDirection: boolean[];\n\n                context.moveTo(points[0], points[1]);\n\n                for (let j = 2; j < points.length; j += 2)\n                {\n                    context.lineTo(points[j], points[j + 1]);\n                }\n\n                if (tempShape.closeStroke)\n                {\n                    context.closePath();\n                }\n\n                if (holes.length > 0)\n                {\n                    holesDirection = [];\n                    outerArea = 0;\n                    px = points[0];\n                    py = points[1];\n                    for (let j = 2; j + 2 < points.length; j += 2)\n                    {\n                        outerArea += ((points[j] - px) * (points[j + 3] - py))\n                            - ((points[j + 2] - px) * (points[j + 1] - py));\n                    }\n\n                    for (let k = 0; k < holes.length; k++)\n                    {\n                        points = (holes[k].shape as Polygon).points;\n\n                        if (!points)\n                        {\n                            continue;\n                        }\n\n                        innerArea = 0;\n                        px = points[0];\n                        py = points[1];\n                        for (let j = 2; j + 2 < points.length; j += 2)\n                        {\n                            innerArea += ((points[j] - px) * (points[j + 3] - py))\n                                - ((points[j + 2] - px) * (points[j + 1] - py));\n                        }\n\n                        if (innerArea * outerArea < 0)\n                        {\n                            context.moveTo(points[0], points[1]);\n\n                            for (let j = 2; j < points.length; j += 2)\n                            {\n                                context.lineTo(points[j], points[j + 1]);\n                            }\n                        }\n                        else\n                        {\n                            context.moveTo(points[points.length - 2], points[points.length - 1]);\n\n                            for (let j = points.length - 4; j >= 0; j -= 2)\n                            {\n                                context.lineTo(points[j], points[j + 1]);\n                            }\n                        }\n\n                        if ((holes[k].shape as Polygon).closeStroke)\n                        {\n                            context.closePath();\n                        }\n\n                        holesDirection[k] = innerArea * outerArea < 0;\n                    }\n                }\n\n                if (fillStyle.visible)\n                {\n                    context.globalAlpha = fillStyle.alpha * worldAlpha;\n                    context.fillStyle = contextFillStyle;\n                    context.fill();\n                }\n\n                if (lineStyle.visible)\n                {\n                    this.paintPolygonStroke(\n                        tempShape, lineStyle, contextStrokeStyle, holes, holesDirection, worldAlpha, context\n                    );\n                }\n            }\n            else if (data.type === SHAPES.RECT)\n            {\n                const tempShape = shape as Rectangle;\n\n                if (fillStyle.visible)\n                {\n                    context.globalAlpha = fillStyle.alpha * worldAlpha;\n                    context.fillStyle = contextFillStyle;\n                    context.fillRect(tempShape.x, tempShape.y, tempShape.width, tempShape.height);\n                }\n\n                if (lineStyle.visible)\n                {\n                    const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));\n                    const width = tempShape.width + (2 * alignmentOffset);\n                    const height = tempShape.height + (2 * alignmentOffset);\n\n                    context.globalAlpha = lineStyle.alpha * worldAlpha;\n                    context.strokeStyle = contextStrokeStyle;\n                    context.strokeRect(tempShape.x - alignmentOffset, tempShape.y - alignmentOffset, width, height);\n                }\n            }\n            else if (data.type === SHAPES.CIRC)\n            {\n                const tempShape = shape as Circle;\n\n                // TODO - need to be Undefined!\n                context.beginPath();\n                context.arc(tempShape.x, tempShape.y, tempShape.radius, 0, 2 * Math.PI);\n                context.closePath();\n\n                if (fillStyle.visible)\n                {\n                    context.globalAlpha = fillStyle.alpha * worldAlpha;\n                    context.fillStyle = contextFillStyle;\n                    context.fill();\n                }\n\n                if (lineStyle.visible)\n                {\n                    if (lineStyle.alignment !== 0.5)\n                    {\n                        const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));\n\n                        context.beginPath();\n                        context.arc(tempShape.x, tempShape.y, tempShape.radius + alignmentOffset, 0, 2 * Math.PI);\n                        context.closePath();\n                    }\n\n                    context.globalAlpha = lineStyle.alpha * worldAlpha;\n                    context.strokeStyle = contextStrokeStyle;\n                    context.stroke();\n                }\n            }\n            else if (data.type === SHAPES.ELIP)\n            {\n                const tempShape = shape as Ellipse;\n                const drawShapeOverStroke = lineStyle.alignment === 1;\n\n                if (!drawShapeOverStroke)\n                {\n                    this.paintEllipse(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);\n                }\n\n                if (lineStyle.visible)\n                {\n                    if (lineStyle.alignment !== 0.5)\n                    {\n                        const kappa = 0.5522848;\n                        const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));\n                        const sW = (tempShape.width + alignmentOffset) * 2;\n                        const sH = (tempShape.height + alignmentOffset) * 2;\n                        const sX = tempShape.x - (sW / 2);\n                        const sY = tempShape.y - (sH / 2);\n                        const sOx = (sW / 2) * kappa;\n                        const sOy = (sH / 2) * kappa;\n                        const sXe = sX + sW;\n                        const sYe = sY + sH;\n                        const sXm = sX + (sW / 2);\n                        const sYm = sY + (sH / 2);\n\n                        context.beginPath();\n                        context.moveTo(sX, sYm);\n                        context.bezierCurveTo(sX, sYm - sOy, sXm - sOx, sY, sXm, sY);\n                        context.bezierCurveTo(sXm + sOx, sY, sXe, sYm - sOy, sXe, sYm);\n                        context.bezierCurveTo(sXe, sYm + sOy, sXm + sOx, sYe, sXm, sYe);\n                        context.bezierCurveTo(sXm - sOx, sYe, sX, sYm + sOy, sX, sYm);\n                        context.closePath();\n                    }\n\n                    context.globalAlpha = lineStyle.alpha * worldAlpha;\n                    context.strokeStyle = contextStrokeStyle;\n                    context.stroke();\n                }\n\n                if (drawShapeOverStroke)\n                {\n                    this.paintEllipse(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);\n                }\n            }\n            else if (data.type === SHAPES.RREC)\n            {\n                const tempShape = shape as RoundedRectangle;\n                const drawShapeOverStroke = lineStyle.alignment === 1;\n\n                if (!drawShapeOverStroke)\n                {\n                    this.paintRoundedRectangle(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);\n                }\n\n                if (lineStyle.visible)\n                {\n                    if (lineStyle.alignment !== 0.5)\n                    {\n                        const width = tempShape.width;\n                        const height = tempShape.height;\n                        const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));\n                        const sRx = tempShape.x - alignmentOffset;\n                        const sRy = tempShape.y - alignmentOffset;\n                        const sWidth = tempShape.width + (2 * alignmentOffset);\n                        const sHeight = tempShape.height + (2 * alignmentOffset);\n                        const radiusOffset = alignmentOffset * (lineStyle.alignment >= 1\n                            ? Math.min(sWidth / width, sHeight / height) : Math.min(width / sWidth, height / sHeight));\n                        let sRadius = tempShape.radius + radiusOffset;\n                        const sMaxRadius = Math.min(sWidth, sHeight) / 2;\n\n                        sRadius = sRadius > sMaxRadius ? sMaxRadius : sRadius;\n\n                        context.beginPath();\n                        context.moveTo(sRx, sRy + sRadius);\n                        context.lineTo(sRx, sRy + sHeight - sRadius);\n                        context.quadraticCurveTo(sRx, sRy + sHeight, sRx + sRadius, sRy + sHeight);\n                        context.lineTo(sRx + sWidth - sRadius, sRy + sHeight);\n                        context.quadraticCurveTo(sRx + sWidth, sRy + sHeight, sRx + sWidth, sRy + sHeight - sRadius);\n                        context.lineTo(sRx + sWidth, sRy + sRadius);\n                        context.quadraticCurveTo(sRx + sWidth, sRy, sRx + sWidth - sRadius, sRy);\n                        context.lineTo(sRx + sRadius, sRy);\n                        context.quadraticCurveTo(sRx, sRy, sRx, sRy + sRadius);\n                        context.closePath();\n                    }\n\n                    context.globalAlpha = lineStyle.alpha * worldAlpha;\n                    context.strokeStyle = contextStrokeStyle;\n                    context.stroke();\n                }\n\n                if (drawShapeOverStroke)\n                {\n                    this.paintRoundedRectangle(tempShape, fillStyle, lineStyle, contextFillStyle, worldAlpha, context);\n                }\n            }\n        }\n    }\n\n    /**\n     * Paint stroke for polygon and holes\n     * @private\n     * @param shape - Shape to be drawn\n     * @param lineStyle - Line style for the shape\n     * @param contextStrokeStyle - The strokeStyle for the canvas context\n     * @param holes - Holes to be added to the shape\n     * @param holesDirection -\n     * @param worldAlpha - The multiplied alpha of the displayObject\n     * @param context - The canvas context\n     */\n    private paintPolygonStroke(\n        shape: Polygon, lineStyle: LineStyle, contextStrokeStyle: string | CanvasPattern,\n        holes: GraphicsData[], holesDirection: boolean[],\n        worldAlpha: number, context: CrossPlatformCanvasRenderingContext2D\n    ): void\n    {\n        if (lineStyle.alignment !== 0.5)\n        {\n            const alignmentOffset = lineStyle.width * (0.5 - (1 - lineStyle.alignment));\n            let offsetPoints = PolygonUtils.offsetPolygon(shape.points, alignmentOffset);\n            let points;\n\n            context.beginPath();\n            context.moveTo(offsetPoints[0], offsetPoints[1]);\n\n            for (let j = 2; j < offsetPoints.length; j += 2)\n            {\n                context.lineTo(offsetPoints[j], offsetPoints[j + 1]);\n            }\n\n            if (shape.closeStroke)\n            {\n                context.closePath();\n            }\n\n            for (let k = 0; k < holes.length; k++)\n            {\n                points = (holes[k].shape as Polygon).points;\n                offsetPoints = PolygonUtils.offsetPolygon(points, alignmentOffset);\n\n                if (holesDirection[k])\n                {\n                    context.moveTo(offsetPoints[0], offsetPoints[1]);\n\n                    for (let j = 2; j < offsetPoints.length; j += 2)\n                    {\n                        context.lineTo(offsetPoints[j], offsetPoints[j + 1]);\n                    }\n                }\n                else\n                {\n                    context.moveTo(offsetPoints[offsetPoints.length - 2], offsetPoints[offsetPoints.length - 1]);\n\n                    for (let j = offsetPoints.length - 4; j >= 0; j -= 2)\n                    {\n                        context.lineTo(offsetPoints[j], offsetPoints[j + 1]);\n                    }\n                }\n\n                if ((holes[k].shape as Polygon).closeStroke)\n                {\n                    context.closePath();\n                }\n            }\n        }\n\n        context.globalAlpha = lineStyle.alpha * worldAlpha;\n        context.strokeStyle = contextStrokeStyle;\n        context.stroke();\n    }\n\n    /**\n     * Paint Ellipse\n     * @private\n     * @param shape - Shape to be drawn\n     * @param fillStyle - Fill for the shape\n     * @param lineStyle - Line style for the shape\n     * @param contextFillStyle - The canvas context fill style\n     * @param worldAlpha - The multiplied alpha of the displayObject\n     * @param context - The canvas context\n     */\n    private paintEllipse(\n        shape: Ellipse, fillStyle: FillStyle, lineStyle: LineStyle,\n        contextFillStyle: string | CanvasPattern, worldAlpha: number,\n        context: CrossPlatformCanvasRenderingContext2D): void\n    {\n        // ellipse code taken from: http://stackoverflow.com/questions/2172798/how-to-draw-an-oval-in-html5-canvas\n        const w = shape.width * 2;\n        const h = shape.height * 2;\n\n        const x = shape.x - (w / 2);\n        const y = shape.y - (h / 2);\n\n        const kappa = 0.5522848;\n        const ox = (w / 2) * kappa; // control point offset horizontal\n        const oy = (h / 2) * kappa; // control point offset vertical\n        const xe = x + w; // x-end\n        const ye = y + h; // y-end\n        const xm = x + (w / 2); // x-middle\n        const ym = y + (h / 2); // y-middle\n\n        if (lineStyle.alignment === 0)\n        {\n            context.save();\n        }\n\n        context.beginPath();\n        context.moveTo(x, ym);\n        context.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);\n        context.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);\n        context.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);\n        context.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);\n        context.closePath();\n\n        if (lineStyle.alignment === 0)\n        {\n            context.clip();\n        }\n\n        if (fillStyle.visible)\n        {\n            context.globalAlpha = fillStyle.alpha * worldAlpha;\n            context.fillStyle = contextFillStyle;\n            context.fill();\n        }\n\n        if (lineStyle.alignment === 0)\n        {\n            context.restore();\n        }\n    }\n\n    /**\n     * Paint Rounded Rectangle\n     * @private\n     * @param shape - Shape to be drawn\n     * @param fillStyle - Fill for the shape\n     * @param lineStyle - Line style for the shape\n     * @param contextFillStyle - The canvas context fill style\n     * @param worldAlpha - The multiplied alpha of the displayObject\n     * @param context - The canvas context\n     */\n    private paintRoundedRectangle(\n        shape: RoundedRectangle, fillStyle: FillStyle, lineStyle: LineStyle,\n        contextFillStyle: string | CanvasPattern, worldAlpha: number,\n        context: CrossPlatformCanvasRenderingContext2D\n    ): void\n    {\n        const rx = shape.x;\n        const ry = shape.y;\n        const width = shape.width;\n        const height = shape.height;\n        let radius = shape.radius;\n\n        const maxRadius = Math.min(width, height) / 2;\n\n        radius = radius > maxRadius ? maxRadius : radius;\n\n        if (lineStyle.alignment === 0)\n        {\n            context.save();\n        }\n\n        context.beginPath();\n        context.moveTo(rx, ry + radius);\n        context.lineTo(rx, ry + height - radius);\n        context.quadraticCurveTo(rx, ry + height, rx + radius, ry + height);\n        context.lineTo(rx + width - radius, ry + height);\n        context.quadraticCurveTo(rx + width, ry + height, rx + width, ry + height - radius);\n        context.lineTo(rx + width, ry + radius);\n        context.quadraticCurveTo(rx + width, ry, rx + width - radius, ry);\n        context.lineTo(rx + radius, ry);\n        context.quadraticCurveTo(rx, ry, rx, ry + radius);\n        context.closePath();\n\n        if (lineStyle.alignment === 0)\n        {\n            context.clip();\n        }\n\n        if (fillStyle.visible)\n        {\n            context.globalAlpha = fillStyle.alpha * worldAlpha;\n            context.fillStyle = contextFillStyle;\n            context.fill();\n        }\n\n        if (lineStyle.alignment === 0)\n        {\n            context.restore();\n        }\n    }\n\n    public setPatternTransform(pattern: CanvasPattern, matrix: Matrix): void\n    {\n        if (this._svgMatrix === false)\n        {\n            return;\n        }\n        if (!this._svgMatrix)\n        {\n            const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');\n\n            if (svg && svg.createSVGMatrix)\n            {\n                this._svgMatrix = svg.createSVGMatrix();\n            }\n            if (!this._svgMatrix || !pattern.setTransform)\n            {\n                this._svgMatrix = false;\n\n                return;\n            }\n        }\n\n        (this._svgMatrix as DOMMatrix).a = matrix.a;\n        (this._svgMatrix as DOMMatrix).b = matrix.b;\n        (this._svgMatrix as DOMMatrix).c = matrix.c;\n        (this._svgMatrix as DOMMatrix).d = matrix.d;\n        (this._svgMatrix as DOMMatrix).e = matrix.tx;\n        (this._svgMatrix as DOMMatrix).f = matrix.ty;\n        pattern.setTransform((this._svgMatrix as DOMMatrix).inverse());\n    }\n\n    /** destroy graphics object */\n    public destroy(): void\n    {\n        this.renderer = null;\n        this._svgMatrix = null;\n        this._tempMatrix = null;\n    }\n}\n","import { SCALE_MODES, BLEND_MODES } from '@pixi/constants';\nimport { Matrix, groupD8 } from '@pixi/math';\nimport { canvasUtils } from '@pixi/canvas-renderer';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\nimport type { Sprite } from '@pixi/sprite';\nimport type { ExtensionMetadata } from '@pixi/core';\nimport { ExtensionType } from '@pixi/core';\n\nconst canvasRenderWorldTransform = new Matrix();\n\n/**\n * Types that can be passed to drawImage\n * @typedef {HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap} ICanvasImageSource\n * @memberof PIXI\n */\n\n/*\n * @author Mat Groves\n *\n * Big thanks to the very clever Matt DesLauriers <mattdesl> https://github.com/mattdesl/\n * for creating the original PixiJS version!\n * Also a thanks to https://github.com/bchevalier for tweaking the tint and alpha so that they now\n * share 4 bytes on the vertex buffer\n *\n * Heavily inspired by LibGDX's CanvasSpriteRenderer:\n * https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/CanvasSpriteRenderer.java\n */\n\n/**\n * Renderer dedicated to drawing and batching sprites.\n * @class\n * @protected\n * @memberof PIXI\n */\nexport class CanvasSpriteRenderer\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'sprite',\n        type: ExtensionType.CanvasRendererPlugin,\n    };\n\n    /** A reference to the current renderer */\n    protected renderer: CanvasRenderer;\n\n    /** @param renderer - A reference to the current renderer */\n    constructor(renderer: CanvasRenderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * Renders the sprite object.\n     * @param sprite - the sprite to render when using this spritebatch\n     */\n    render(sprite: Sprite): void\n    {\n        const texture = sprite._texture;\n        const renderer = this.renderer;\n        const context = renderer.context;\n\n        if (!texture.valid)\n        {\n            return;\n        }\n\n        const sourceWidth = texture._frame.width;\n        const sourceHeight = texture._frame.height;\n\n        let destWidth = texture._frame.width;\n        let destHeight = texture._frame.height;\n\n        if (texture.trim)\n        {\n            if (groupD8.isVertical(texture.rotate))\n            {\n                destWidth = texture.trim.height;\n                destHeight = texture.trim.width;\n            }\n            else\n            {\n                destWidth = texture.trim.width;\n                destHeight = texture.trim.height;\n            }\n        }\n\n        let wt = sprite.transform.worldTransform;\n        let dx = 0;\n        let dy = 0;\n\n        const source = texture.baseTexture.getDrawableSource();\n\n        if (texture.orig.width <= 0 || texture.orig.height <= 0 || !texture.valid || !source)\n        {\n            return;\n        }\n\n        renderer.setBlendMode(sprite.blendMode, true);\n\n        renderer.context.globalAlpha = sprite.worldAlpha;\n\n        // If smoothingEnabled is supported and we need to change the smoothing property for sprite texture\n        const smoothingEnabled = texture.baseTexture.scaleMode === SCALE_MODES.LINEAR;\n\n        if (renderer.smoothProperty\n            && renderer.context[renderer.smoothProperty] !== smoothingEnabled)\n        {\n            context[renderer.smoothProperty] = smoothingEnabled;\n        }\n\n        if (texture.trim)\n        {\n            dx = (texture.trim.width / 2) + texture.trim.x - (sprite.anchor.x * texture.orig.width);\n            dy = (texture.trim.height / 2) + texture.trim.y - (sprite.anchor.y * texture.orig.height);\n        }\n        else\n        {\n            dx = (0.5 - sprite.anchor.x) * texture.orig.width;\n            dy = (0.5 - sprite.anchor.y) * texture.orig.height;\n        }\n\n        if (texture.rotate)\n        {\n            wt.copyTo(canvasRenderWorldTransform);\n            wt = canvasRenderWorldTransform;\n            groupD8.matrixAppendRotationInv(wt, texture.rotate, dx, dy);\n            // the anchor has already been applied above, so lets set it to zero\n            dx = 0;\n            dy = 0;\n        }\n\n        dx -= destWidth / 2;\n        dy -= destHeight / 2;\n\n        renderer.setContextTransform(wt, sprite.roundPixels, 1);\n        // Allow for pixel rounding\n        if (sprite.roundPixels)\n        {\n            dx = dx | 0;\n            dy = dy | 0;\n        }\n\n        const resolution = texture.baseTexture.resolution;\n        const outerBlend = renderer._outerBlend;\n\n        if (outerBlend)\n        {\n            context.save();\n            context.beginPath();\n            context.rect(\n                dx * renderer.resolution,\n                dy * renderer.resolution,\n                destWidth * renderer.resolution,\n                destHeight * renderer.resolution\n            );\n            context.clip();\n        }\n\n        if (sprite.tint !== 0xFFFFFF)\n        {\n            if (sprite._cachedTint !== sprite.tint || sprite._tintedCanvas.tintId !== sprite._texture._updateID)\n            {\n                sprite._cachedTint = sprite.tint;\n\n                // TODO clean up caching - how to clean up the caches?\n                sprite._tintedCanvas = canvasUtils.getTintedCanvas(sprite, sprite.tint);\n            }\n\n            context.drawImage(\n                sprite._tintedCanvas,\n                0,\n                0,\n                Math.floor(sourceWidth * resolution),\n                Math.floor(sourceHeight * resolution),\n                Math.floor(dx * renderer.resolution),\n                Math.floor(dy * renderer.resolution),\n                Math.floor(destWidth * renderer.resolution),\n                Math.floor(destHeight * renderer.resolution)\n            );\n        }\n        else\n        {\n            context.drawImage(\n                source,\n                texture._frame.x * resolution,\n                texture._frame.y * resolution,\n                Math.floor(sourceWidth * resolution),\n                Math.floor(sourceHeight * resolution),\n                Math.floor(dx * renderer.resolution),\n                Math.floor(dy * renderer.resolution),\n                Math.floor(destWidth * renderer.resolution),\n                Math.floor(destHeight * renderer.resolution)\n            );\n        }\n\n        if (outerBlend)\n        {\n            context.restore();\n        }\n        // just in case, leaking outer blend here will be catastrophic!\n        renderer.setBlendMode(BLEND_MODES.NORMAL);\n    }\n\n    /** destroy the sprite object */\n    destroy(): void\n    {\n        this.renderer = null;\n    }\n}\n","import { Sprite } from '@pixi/sprite';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Cached tinted texture.\n * @memberof PIXI.Sprite#\n * @member {HTMLCanvasElement} _tintedCanvas\n * @protected\n */\nSprite.prototype._tintedCanvas = null;\n\n/**\n * Renders the object using the Canvas renderer\n * @private\n * @method _renderCanvas\n * @memberof PIXI.Sprite#\n * @param {PIXI.CanvasRenderer} renderer - The renderer\n */\nSprite.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    renderer.plugins.sprite.render(this);\n};\n","import { ExtensionType, RenderTexture } from '@pixi/core';\nimport { CanvasRenderTarget } from '@pixi/utils';\nimport { Rectangle } from '@pixi/math';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\nimport type { DisplayObject } from '@pixi/display';\nimport type { BaseRenderTexture, ExtensionMetadata } from '@pixi/core';\n\nconst TEMP_RECT = new Rectangle();\n\n/**\n * The extract manager provides functionality to export content from the renderers.\n *\n * An instance of this class is automatically created by default, and can be found at `renderer.plugins.extract`\n * @class\n * @memberof PIXI\n */\nexport class CanvasExtract\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'extract',\n        type: ExtensionType.CanvasRendererPlugin,\n    };\n\n    /** A reference to the current renderer */\n    public renderer: CanvasRenderer;\n\n    /**\n     * @param renderer - A reference to the current renderer\n     */\n    constructor(renderer: CanvasRenderer)\n    {\n        this.renderer = renderer;\n    }\n\n    /**\n     * Will return a HTML Image of the target\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param format - Image format, e.g. \"image/jpeg\" or \"image/webp\".\n     * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.\n     * @returns HTML Image of the target\n     */\n    public image(target?: DisplayObject | RenderTexture, format?: string, quality?: number): HTMLImageElement\n    {\n        const image = new Image();\n\n        image.src = this.base64(target, format, quality);\n\n        return image;\n    }\n\n    /**\n     * Will return a base64 encoded string of this target. It works by calling\n     *  `CanvasExtract.getCanvas` and then running toDataURL on that.\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param format - Image format, e.g. \"image/jpeg\" or \"image/webp\".\n     * @param quality - JPEG or Webp compression from 0 to 1. Default is 0.92.\n     * @returns A base64 encoded string of the texture.\n     */\n    public base64(target?: DisplayObject | RenderTexture, format?: string, quality?: number): string\n    {\n        return this.canvas(target).toDataURL(format, quality);\n    }\n\n    /**\n     * Creates a Canvas element, renders this target to it and then returns it.\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param frame - The frame the extraction is restricted to.\n     * @returns A Canvas element with the texture rendered on.\n     */\n    public canvas(target?: DisplayObject | RenderTexture, frame?: Rectangle): HTMLCanvasElement\n    {\n        const renderer = this.renderer;\n        let context;\n        let resolution;\n        let renderTexture;\n\n        if (target)\n        {\n            if (target instanceof RenderTexture)\n            {\n                renderTexture = target;\n            }\n            else\n            {\n                renderTexture = renderer.generateTexture(target);\n            }\n        }\n\n        if (renderTexture)\n        {\n            context = (renderTexture.baseTexture as BaseRenderTexture)._canvasRenderTarget.context;\n            resolution = (renderTexture.baseTexture as BaseRenderTexture)._canvasRenderTarget.resolution;\n            frame = frame ?? renderTexture.frame;\n        }\n        else\n        {\n            context = renderer.rootContext;\n            resolution = renderer.resolution;\n\n            if (!frame)\n            {\n                frame = TEMP_RECT;\n                frame.width = renderer.width;\n                frame.height = renderer.height;\n            }\n        }\n\n        const x = Math.round(frame.x * resolution);\n        const y = Math.round(frame.y * resolution);\n        const width = Math.round(frame.width * resolution);\n        const height = Math.round(frame.height * resolution);\n\n        const canvasBuffer = new CanvasRenderTarget(width, height, 1);\n        const canvasData = context.getImageData(x, y, width, height);\n\n        canvasBuffer.context.putImageData(canvasData, 0, 0);\n\n        // send the canvas back..\n        return canvasBuffer.canvas;\n    }\n\n    /**\n     * Will return a one-dimensional array containing the pixel data of the entire texture in RGBA\n     * order, with integer values between 0 and 255 (included).\n     * @param target - A displayObject or renderTexture\n     *  to convert. If left empty will use the main renderer\n     * @param frame - The frame the extraction is restricted to.\n     * @returns One-dimensional array containing the pixel data of the entire texture\n     */\n    public pixels(target?: DisplayObject | RenderTexture, frame?: Rectangle): Uint8ClampedArray\n    {\n        const renderer = this.renderer;\n        let context;\n        let resolution;\n        let renderTexture;\n\n        if (target)\n        {\n            if (target instanceof RenderTexture)\n            {\n                renderTexture = target;\n            }\n            else\n            {\n                renderTexture = renderer.generateTexture(target);\n            }\n        }\n\n        if (renderTexture)\n        {\n            context = (renderTexture.baseTexture as BaseRenderTexture)._canvasRenderTarget.context;\n            resolution = (renderTexture.baseTexture as BaseRenderTexture)._canvasRenderTarget.resolution;\n            frame = frame ?? renderTexture.frame;\n        }\n        else\n        {\n            context = renderer.rootContext;\n            resolution = renderer.resolution;\n\n            if (!frame)\n            {\n                frame = TEMP_RECT;\n                frame.width = renderer.width;\n                frame.height = renderer.height;\n            }\n        }\n\n        const x = Math.round(frame.x * resolution);\n        const y = Math.round(frame.y * resolution);\n        const width = Math.round(frame.width * resolution);\n        const height = Math.round(frame.height * resolution);\n\n        return context.getImageData(x, y, width, height).data;\n    }\n\n    /** Destroys the extract */\n    public destroy(): void\n    {\n        this.renderer = null;\n    }\n}\n","import { BaseTexture, ExtensionType } from '@pixi/core';\nimport { BasePrepare } from '@pixi/prepare';\nimport { settings } from '@pixi/settings';\n\nimport type { AbstractRenderer, ExtensionMetadata } from '@pixi/core';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\nimport type { IDisplayObjectExtended } from '@pixi/prepare';\n\nconst CANVAS_START_SIZE = 16;\n\n/**\n * Built-in hook to upload PIXI.Texture objects to the GPU.\n * @private\n * @param prepare - Instance of CanvasPrepare\n * @param item - Item to check\n * @returns If item was uploaded.\n */\nfunction uploadBaseTextures(prepare: AbstractRenderer | BasePrepare, item: IDisplayObjectExtended): boolean\n{\n    const tempPrepare = prepare as CanvasPrepare;\n\n    if (item instanceof BaseTexture)\n    {\n        const image = (item as any).source;\n\n        // Sometimes images (like atlas images) report a size of zero, causing errors on windows phone.\n        // So if the width or height is equal to zero then use the canvas size\n        // Otherwise use whatever is smaller, the image dimensions or the canvas dimensions.\n        const imageWidth = image.width === 0 ? tempPrepare.canvas.width : Math.min(tempPrepare.canvas.width, image.width);\n        const imageHeight = image.height === 0 ? tempPrepare.canvas.height\n            : Math.min(tempPrepare.canvas.height, image.height);\n\n        // Only a small subsections is required to be drawn to have the whole texture uploaded to the GPU\n        // A smaller draw can be faster.\n        tempPrepare.ctx.drawImage(\n            image, 0, 0, imageWidth, imageHeight, 0, 0,\n            tempPrepare.canvas.width, tempPrepare.canvas.height\n        );\n\n        return true;\n    }\n\n    return false;\n}\n\n/**\n * The prepare manager provides functionality to upload content to the GPU.\n *\n * This cannot be done directly for Canvas like in WebGL, but the effect can be achieved by drawing\n * textures to an offline canvas. This draw call will force the texture to be moved onto the GPU.\n *\n * An instance of this class is automatically created by default, and can be found at `renderer.plugins.prepare`\n * @class\n * @extends PIXI.BasePrepare\n * @memberof PIXI\n */\nexport class CanvasPrepare extends BasePrepare\n{\n    /** @ignore */\n    static extension: ExtensionMetadata = {\n        name: 'prepare',\n        type: ExtensionType.CanvasRendererPlugin,\n    };\n\n    /**\n     * An offline canvas to render textures to\n     * @internal\n     */\n    canvas: HTMLCanvasElement;\n    /**\n     * The context to the canvas\n     * @internal\n     */\n    ctx: CanvasRenderingContext2D;\n\n    /**\n     * @param renderer - A reference to the current renderer\n     */\n    constructor(renderer: CanvasRenderer)\n    {\n        super(renderer);\n\n        this.uploadHookHelper = this;\n\n        this.canvas = settings.ADAPTER.createCanvas(\n            CANVAS_START_SIZE,\n            CANVAS_START_SIZE\n        );\n\n        this.ctx = this.canvas.getContext('2d');\n\n        // Add textures to upload\n        this.registerUploadHook(uploadBaseTextures);\n    }\n\n    /** Destroys the plugin, don't use after this */\n    public destroy(): void\n    {\n        super.destroy();\n        this.ctx = null;\n        this.canvas = null;\n    }\n}\n","import { TilingSprite } from '@pixi/sprite-tiling';\nimport { canvasUtils } from '@pixi/canvas-renderer';\nimport { CanvasRenderTarget } from '@pixi/utils';\nimport { Matrix, Point } from '@pixi/math';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\nconst worldMatrix = new Matrix();\nconst patternMatrix = new Matrix();\nconst patternRect = [new Point(), new Point(), new Point(), new Point()];\n\n/**\n * Renders the object using the Canvas renderer\n * @protected\n * @function _renderCanvas\n * @memberof PIXI.TilingSprite#\n * @param {PIXI.CanvasRenderer} renderer - a reference to the canvas renderer\n */\nTilingSprite.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    const texture = this._texture;\n\n    if (!texture.baseTexture.valid)\n    {\n        return;\n    }\n\n    const context = renderer.context;\n    const transform = this.worldTransform;\n    const baseTexture = texture.baseTexture;\n    const source = baseTexture.getDrawableSource();\n    const baseTextureResolution = baseTexture.resolution;\n\n    // create a nice shiny pattern!\n    if (this._textureID !== this._texture._updateID || this._cachedTint !== this.tint)\n    {\n        this._textureID = this._texture._updateID;\n        // cut an object from a spritesheet..\n        const tempCanvas = new CanvasRenderTarget(texture._frame.width,\n            texture._frame.height,\n            baseTextureResolution);\n\n        // Tint the tiling sprite\n        if (this.tint !== 0xFFFFFF)\n        {\n            this._tintedCanvas = canvasUtils.getTintedCanvas(this, this.tint) as HTMLCanvasElement;\n            tempCanvas.context.drawImage(this._tintedCanvas, 0, 0);\n        }\n        else\n        {\n            tempCanvas.context.drawImage(source,\n                -texture._frame.x * baseTextureResolution, -texture._frame.y * baseTextureResolution);\n        }\n        this._cachedTint = this.tint;\n        this._canvasPattern = tempCanvas.context.createPattern(tempCanvas.canvas, 'repeat');\n    }\n\n    // set context state..\n    context.globalAlpha = this.worldAlpha;\n    renderer.setBlendMode(this.blendMode);\n\n    this.tileTransform.updateLocalTransform();\n    const lt = this.tileTransform.localTransform;\n    const W = this._width;\n    const H = this._height;\n\n    /*\n     * # Implementation Notes\n     *\n     * The tiling transform is not simply a transform on the tiling sprite's local space. If that\n     * were, the bounds of the tiling sprite would change. Rather the tile transform is a transform\n     * on the \"pattern\" coordinates each vertex is assigned.\n     *\n     * To implement the `tileTransform`, we issue drawing commands in the pattern's own space, which\n     * is defined as:\n     *\n     * Pattern_Space = Local_Space x inverse(tileTransform)\n     *\n     * In other words,\n     * Local_Space = Pattern_Space x tileTransform\n     *\n     * We draw the pattern in pattern space, because the space we draw in defines the pattern's coordinates.\n     * In other words, the pattern will always \"originate\" from (0, 0) in the space we draw in.\n     *\n     * This technique is equivalent to drawing a pattern texture, and then finding a quadrilateral that becomes\n     * the tiling sprite's local bounds under the tileTransform and mapping that onto the screen.\n     *\n     * ## uvRespectAnchor\n     *\n     * The preceding paragraph discusses the case without considering `uvRespectAnchor`. The `uvRespectAnchor` flags\n     * where the origin of the pattern space is. Assuming the tileTransform includes no translation, without\n     * loss of generality: If uvRespectAnchor = true, then\n     *\n     * Local Space (0, 0) <--> Pattern Space (0, 0) (where <--> means \"maps to\")\n     *\n     * Here the mapping is provided by trivially by the tileTransform (note tileTransform includes no translation. That\n     * means the invariant under all other transforms are the origins)\n     *\n     * Otherwise,\n     *\n     * Local Space (-localBounds.x, -localBounds.y) <--> Pattern Space (0, 0)\n     *\n     * Here the mapping is provided by the tileTransfrom PLUS some \"shift\". This shift is done POST-tileTransform. The shift\n     * is equal to the position of the top-left corner of the tiling sprite in its local space.\n     *\n     * Hence,\n     *\n     * Local_Space = Pattern_Space x tileTransform x shiftTransform\n     */\n\n    // worldMatrix is used to convert from pattern space to world space.\n    //\n    // worldMatrix = tileTransform x shiftTransform x worldTransfrom\n    //             = patternMatrix x worldTransform\n    worldMatrix.identity();\n\n    // patternMatrix is used to convert from pattern space to local space. The drawing commands are issued in pattern space\n    // and this matrix is used to inverse-map the local space vertices into it.\n    //\n    // patternMatrix = tileTransfrom x shiftTransform\n    patternMatrix.copyFrom(lt);\n\n    // Apply shiftTransform into patternMatrix. See $1.1\n    if (!this.uvRespectAnchor)\n    {\n        patternMatrix.translate(-this.anchor.x * W, -this.anchor.y * H);\n    }\n\n    patternMatrix.scale(this.tileScale.x / baseTextureResolution, this.tileScale.y / baseTextureResolution);\n    worldMatrix.prepend(patternMatrix);\n    worldMatrix.prepend(transform);\n\n    renderer.setContextTransform(worldMatrix);\n\n    // Fill the pattern!\n    context.fillStyle = this._canvasPattern;\n\n    // The position in local space we are drawing the rectangle: (lx, ly, lx + W, ly + H)\n    const lx = this.anchor.x * -W;\n    const ly = this.anchor.y * -H;\n\n    // Set pattern rect in local space first.\n    patternRect[0].set(lx, ly);\n    patternRect[1].set(lx + W, ly);\n    patternRect[2].set(lx + W, ly + H);\n    patternRect[3].set(lx, ly + H);\n\n    // Map patternRect into pattern space.\n    for (let i = 0; i < 4; i++)\n    {\n        patternMatrix.applyInverse(patternRect[i], patternRect[i]);\n    }\n\n    /*\n     * # Note about verification of theory\n     *\n     * As discussed in the implementation notes, you can verify that `patternRect[0]` will always be (0, 0) in case of\n     * `uvRespectAnchor` false and tileTransform having no translation. Indeed, because the pattern origin should map\n     * to the top-left corner of the tiling sprite in its local space.\n     */\n\n    context.beginPath();\n    context.moveTo(patternRect[0].x, patternRect[0].y);\n\n    for (let i = 1; i < 4; i++)\n    {\n        context.lineTo(patternRect[i].x, patternRect[i].y);\n    }\n\n    context.closePath();\n    context.fill();\n};\n","import { ParticleContainer } from '@pixi/particle-container';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the object using the Canvas renderer\n * @method renderCanvas\n * @memberof PIXI.ParticleContainer#\n * @private\n * @param {PIXI.CanvasRenderer} renderer - a reference to the canvas renderer\n */\nParticleContainer.prototype.renderCanvas = function renderCanvas(renderer: CanvasRenderer): void\n{\n    if (!this.visible || this.worldAlpha <= 0 || !this.children.length || !this.renderable)\n    {\n        return;\n    }\n\n    const context = renderer.context;\n    const transform = this.worldTransform;\n    let isRotated = true;\n\n    let positionX = 0;\n    let positionY = 0;\n\n    let finalWidth = 0;\n    let finalHeight = 0;\n\n    renderer.setBlendMode(this.blendMode);\n\n    context.globalAlpha = this.worldAlpha;\n\n    this.displayObjectUpdateTransform();\n\n    for (let i = 0; i < this.children.length; ++i)\n    {\n        const child = this.children[i];\n\n        if (!child.visible)\n        {\n            continue;\n        }\n\n        if (!child._texture.valid)\n        {\n            continue;\n        }\n\n        const frame = child._texture.frame;\n\n        context.globalAlpha = this.worldAlpha * child.alpha;\n\n        if (child.rotation % (Math.PI * 2) === 0)\n        {\n            // this is the fastest  way to optimise! - if rotation is 0 then we can avoid any kind of setTransform call\n            if (isRotated)\n            {\n                renderer.setContextTransform(transform, false, 1);\n                isRotated = false;\n            }\n\n            positionX = ((child.anchor.x) * (-frame.width * child.scale.x)) + child.position.x + 0.5;\n            positionY = ((child.anchor.y) * (-frame.height * child.scale.y)) + child.position.y + 0.5;\n\n            finalWidth = frame.width * child.scale.x;\n            finalHeight = frame.height * child.scale.y;\n        }\n        else\n        {\n            if (!isRotated)\n            {\n                isRotated = true;\n            }\n\n            child.displayObjectUpdateTransform();\n\n            const childTransform = child.worldTransform;\n\n            renderer.setContextTransform(childTransform, this.roundPixels, 1);\n\n            positionX = ((child.anchor.x) * (-frame.width)) + 0.5;\n            positionY = ((child.anchor.y) * (-frame.height)) + 0.5;\n\n            finalWidth = frame.width;\n            finalHeight = frame.height;\n        }\n\n        const resolution = child._texture.baseTexture.resolution;\n\n        context.drawImage(\n            child._texture.baseTexture.getDrawableSource(),\n            frame.x * resolution,\n            frame.y * resolution,\n            frame.width * resolution,\n            frame.height * resolution,\n            positionX * renderer.resolution,\n            positionY * renderer.resolution,\n            finalWidth * renderer.resolution,\n            finalHeight * renderer.resolution\n        );\n    }\n};\n","import { Container } from '@pixi/display';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\nimport type { MaskData } from '@pixi/core';\n\n/**\n * To be overridden by the subclass\n * @method _renderCanvas\n * @memberof PIXI.Container#\n * @protected\n * @param {PIXI.CanvasRenderer} _renderer - The renderer\n */\nContainer.prototype._renderCanvas = function _renderCanvas(_renderer: CanvasRenderer): void\n{\n    // this is where content itself gets rendered...\n};\n\n/**\n * Renders the object using the Canvas renderer\n * @method renderCanvas\n * @memberof PIXI.Container#\n * @param {PIXI.CanvasRenderer} renderer - The renderer\n */\nContainer.prototype.renderCanvas = function renderCanvas(renderer: CanvasRenderer): void\n{\n    // if not visible or the alpha is 0 then no need to render this\n    if (!this.visible || this.worldAlpha <= 0 || !this.renderable)\n    {\n        return;\n    }\n\n    if (this._mask)\n    {\n        renderer.maskManager.pushMask(this._mask as MaskData);\n    }\n\n    this._renderCanvas(renderer);\n    for (let i = 0, j = this.children.length; i < j; ++i)\n    {\n        this.children[i].renderCanvas(renderer);\n    }\n\n    if (this._mask)\n    {\n        renderer.maskManager.popMask(renderer);\n    }\n};\n","import { DisplayObject } from '@pixi/display';\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the object using the Canvas renderer\n * @method renderCanvas\n * @memberof PIXI.Container#\n * @param {PIXI.CanvasRenderer} _renderer - The renderer\n */\nDisplayObject.prototype.renderCanvas = function renderCanvas(_renderer: CanvasRenderer): void\n{\n    // OVERWRITE;\n};\n","import { Text } from '@pixi/text';\nimport { Sprite } from '@pixi/sprite';\n\nimport type { CanvasRenderer } from '@pixi/canvas-renderer';\n\n/**\n * Renders the object using the Canvas renderer\n * @method _renderCanvas\n * @memberof PIXI.Text#\n * @private\n * @param {PIXI.CanvasRenderer} renderer - The renderer\n */\nText.prototype._renderCanvas = function _renderCanvas(renderer: CanvasRenderer): void\n{\n    if (this._autoResolution && this._resolution !== renderer.resolution)\n    {\n        this._resolution = renderer.resolution;\n        this.dirty = true;\n    }\n\n    this.updateText(true);\n\n    Sprite.prototype._renderCanvas.call(this, renderer);\n};\n","import { extensions } from 'pixi.js';\nimport { CanvasRenderer, canvasUtils } from '@pixi/canvas-renderer';\nimport { CanvasMeshRenderer } from '@pixi/canvas-mesh';\nimport { CanvasGraphicsRenderer } from '@pixi/canvas-graphics';\nimport { CanvasSpriteRenderer } from '@pixi/canvas-sprite';\nimport { CanvasExtract } from '@pixi/canvas-extract';\nimport { CanvasPrepare } from '@pixi/canvas-prepare';\nimport '@pixi/canvas-sprite-tiling';\nimport '@pixi/canvas-particle-container';\nimport '@pixi/canvas-display';\nimport '@pixi/canvas-text';\n\nextensions.add(\n    CanvasExtract,\n    CanvasGraphicsRenderer,\n    CanvasMeshRenderer,\n    CanvasPrepare,\n    CanvasSpriteRenderer\n);\n\n// Export ES for those importing specifically by name,\n// e.g., `import {autoDetectRenderer} from 'pixi.js-legacy'`\nexport * from 'pixi.js';\nexport {\n    CanvasRenderer,\n    CanvasGraphicsRenderer,\n    CanvasMeshRenderer,\n    CanvasSpriteRenderer,\n    CanvasExtract,\n    CanvasPrepare,\n    canvasUtils,\n};\n"],"names":["getOwnPropertySymbols","Object","hasOwnProperty","prototype","propIsEnumerable","propertyIsEnumerable","module","exports","assign","test1","String","getOwnPropertyNames","test2","i","fromCharCode","map","n","join","test3","split","forEach","letter","keys","err","shouldUseNative","target","source","from","symbols","to","val","undefined","TypeError","toObject","s","arguments","length","key","call","callback","constructor","this","then","value","resolve","reason","reject","arr","args","Array","slice","remaining","res","e","status","AggregateError","errors","message","name","Error","P","rejectionReasons","catch","error","push","ex","setTimeoutFunc","setTimeout","isArray","x","Boolean","noop","Promise","fn","_state","_handled","_value","_deferreds","doResolve","handle","self","deferred","_immediateFn","cb","onFulfilled","onRejected","ret","promise","newValue","finale","thisArg","apply","_unhandledRejectionFn","len","Handler","done","prom","promiseFinally","all","any","allSettled","race","setImmediate","console","warn","globalThis","global","Polyfill","objectAssign","Date","now","getTime","performance","startTime_1","lastTime","vendors","requestAnimationFrame","p","cancelAnimationFrame","currentTime","delay","id","clearTimeout","Math","sign","Number","isNaN","isInteger","isFinite","floor","ArrayBuffer","Float32Array","Uint32Array","Uint16Array","Uint8Array","Int32Array","accessibleTarget","accessible","accessibleTitle","accessibleHint","tabIndex","_accessibleActive","_accessibleDiv","accessibleType","accessiblePointerEvents","accessibleChildren","renderId","DisplayObject","DIV_TOUCH_SIZE","DIV_TOUCH_POS_X","DIV_TOUCH_POS_Y","DIV_TOUCH_ZINDEX","renderer","androidUpdateFrequency","_hookDiv","isMobile","createTouchHook","div","document","createElement","style","width","height","position","top","left","zIndex","toString","_onKeyDown","bind","_onMouseMove","addEventListener","AccessibilityManager","get","_isActive","_isMobileAccessibility","_this","hookDiv","DIV_HOOK_SIZE","DIV_HOOK_POS_X","DIV_HOOK_POS_Y","backgroundColor","title","activate","destroyTouchHook","body","appendChild","removeChild","removeEventListener","on","update","view","parentNode","off","displayObject","visible","interactive","addChild","children","updateAccessibleObjects","androidUpdateCount","renderingToScreen","_lastObjectRendered","getBoundingClientRect","viewWidth","viewHeight","resolution","sx","sy","child","removeItems","pool","hitArea","wt","worldTransform","tx","a","ty","y","d","getBounds","capHitArea","getAttribute","setAttribute","debug","updateDebugHTML","innerHTML","type","pop","borderStyle","navigator","userAgent","toLowerCase","indexOf","match","_onClick","_onFocus","_onFocusOut","pointerEvents","interactionManager","plugins","interaction","eventData","dispatchEvent","keyCode","movementX","movementY","deactivate","ExtensionType","Point","originalEvent","identifier","isPrimary","button","buttons","tiltX","tiltY","pointerType","pressure","rotationAngle","twist","tangentialPressure","InteractionData","point","globalPos","applyInverse","event","which","extendStatics","b","setPrototypeOf","__proto__","stopped","stopsPropagatingAt","stopPropagationHint","currentTarget","data","InteractionEvent","pointerId","_pointerId","_flags","InteractionTrackingData","FLAGS","NONE","flag","yn","set","flags","OVER","_doSet","RIGHT_DOWN","LEFT_DOWN","freeze","_tempPoint","TreeSearch","interactionEvent","func","hitTest","hit","interactiveParent","hitTestChildren","contains","_mask","maskObject","isMaskData","containsPoint","interactiveChildren","childHit","recursiveFindHit","parent","interactiveTarget","buttonMode","cursor","trackedPointers","_trackedPointers","INTERNAL_FORMATS","MOUSE_POINTER_ID","hitTestEvent","InteractionManager","options","_super","autoPreventDefault","interactionFrequency","mouse","activeInteractionData","interactionDataPool","interactionDOMElement","moveWhenInside","eventsAdded","tickerAdded","mouseOverRenderer","supportsTouchEvents","supportsPointerEvents","PointerEvent","onPointerUp","processPointerUp","onPointerCancel","processPointerCancel","onPointerDown","processPointerDown","onPointerMove","processPointerMove","onPointerOut","processPointerOverOut","onPointerOver","cursorStyles","default","pointer","currentCursorMode","delayedEvents","search","_tempDisplayObject","TemporaryDisplayObject","_eventListenerOptions","capture","passive","_useSystemTicker","useSystemTicker","setTargetElement","__","create","__extends","addTickerListener","removeTickerListener","globalPoint","root","lastObjectRendered","processInteractive","element","removeEvents","addEvents","Ticker","tickerUpdate","UPDATE_PRIORITY","msPointerEnabled","msContentZooming","msTouchAction","touchAction","deltaTime","_deltaTime","_didMove","k","interactionData","configureInteractionEventForDOMEvent","setCursorMode","mode","applyStyles","OffscreenCanvas","eventString","emit","rect","parentElement","resolutionMultiplier","findHit","delayedLen","displayObject_1","events","normalizeToPointerData","isNormalized","cancelable","preventDefault","eventLen","getInteractionDataForPointerId","isRightButton","rightDown","leftDown","cancelled","composedPath","eventAppend","releaseInteractionDataForPointerId","onPointerComplete","trackingData","isTouch","isMouse","isMouseTap","test","isDown","over","none","delayDispatchEvent","copyEvent","reset","pointerEvent","mapPositionToPoint","clientX","clientY","globalX","globalY","normalizedEvents","TouchEvent","li","changedTouches","touch","touches","radiusX","radiusY","force","layerX","offsetX","layerY","offsetY","MouseEvent","tempEvent","removeAllListeners","EventEmitter","TEMP_RECT","Rectangle","Extract","format","quality","image","Image","src","base64","canvas","toDataURL","frame","_rawPixels","pixels","flipY","canvasBuffer","CanvasRenderTarget","canvasData","context","getImageData","arrayPostDivide","putImageData","target_1","scale","drawImage","destroy","renderTexture","generated","RenderTexture","multisample","webGLVersion","MSAA_QUALITY","generateTexture","resolvedTexture","framebuffer","blit","baseTexture","round","gl","readPixels","RGBA","UNSIGNED_BYTE","out","alpha","min","INTERNAL_FORMAT_TO_BYTES_PER_PIXEL","COMPRESSED_RGB_S3TC_DXT1_EXT","_a","COMPRESSED_RGBA_S3TC_DXT1_EXT","COMPRESSED_RGBA_S3TC_DXT3_EXT","COMPRESSED_RGBA_S3TC_DXT5_EXT","COMPRESSED_SRGB_S3TC_DXT1_EXT","COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT","COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT","COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT","COMPRESSED_R11_EAC","COMPRESSED_SIGNED_R11_EAC","COMPRESSED_RG11_EAC","COMPRESSED_SIGNED_RG11_EAC","COMPRESSED_RGB8_ETC2","COMPRESSED_RGBA8_ETC2_EAC","COMPRESSED_SRGB8_ETC2","COMPRESSED_SRGB8_ALPHA8_ETC2_EAC","COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2","COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2","COMPRESSED_RGB_PVRTC_4BPPV1_IMG","COMPRESSED_RGBA_PVRTC_4BPPV1_IMG","COMPRESSED_RGB_PVRTC_2BPPV1_IMG","COMPRESSED_RGBA_PVRTC_2BPPV1_IMG","COMPRESSED_RGB_ETC1_WEBGL","COMPRESSED_RGB_ATC_WEBGL","COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL","COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL","COMPRESSED_RGBA_ASTC_4x4_KHR","__awaiter","_arguments","generator","fulfilled","step","next","rejected","result","__generator","f","t","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","BlobResource","autoLoad","origin","buffer","ViewableBuffer","load","loaded","onBlobLoaded","rawBinaryData","_data","fetch","blob","arrayBuffer","BufferResource","CompressedTextureResource","levels","_width","_height","_extension","_formatToExtension","levelBuffers","_levelBuffers","_createLevelBuffers","uint8View","_texture","_glTexture","extensions","j","levelID","levelWidth","levelHeight","levelBuffer","compressedTexImage2D","TEXTURE_2D","blockWidth","blockHeight","imageWidth","imageHeight","buffers","offset","byteOffset","alignedLevelWidth","alignedLevelHeight","levelSize","CompressedTextureLoader","resource","LoaderResource","cacheID","textures","textureURL","fallbackURL","texture","url_1","textureFormats","url","loadOptions","crossOrigin","metadata","imageMetadata","parentResource","resourcePath","replace","baseUrl","resourceName","add","_b","_textureExtensions","settings","getContext","s3tc","getExtension","s3tc_sRGB","etc","etc1","pvrtc","atc","astc","_textureFormats","textureExtensions","extensionName","extension","getPrototypeOf","registerCompressedTextures","resources","Texture","BaseTexture","mipmap","MIPMAP_MODES","alphaMode","ALPHA_MODES","DXGI_FORMAT","D3D10_RESOURCE_DIMENSION","DDS_MAGIC_SIZE","DDS_HEADER_SIZE","DDS_HEADER_PF_SIZE","DDS_HEADER_DX10_SIZE","DDS_MAGIC","DDS_FIELDS","SIZE","HEIGHT","WIDTH","MIPMAP_COUNT","PIXEL_FORMAT","DDS_PF_FIELDS","FOURCC","RGB_BITCOUNT","R_BIT_MASK","G_BIT_MASK","B_BIT_MASK","A_BIT_MASK","DDS_DX10_FIELDS","RESOURCE_DIMENSION","MISC_FLAG","ARRAY_SIZE","MISC_FLAGS2","PF_FLAGS","DDPF_ALPHA","DDPF_FOURCC","DDPF_RGB","DDPF_YUV","DDPF_LUMINANCE","FOURCC_DX10","DDS_RESOURCE_MISC_TEXTURECUBE","FOURCC_TO_FORMAT","DXGI_TO_FORMAT","DXGI_FORMAT_BC1_TYPELESS","DXGI_FORMAT_BC1_UNORM","DXGI_FORMAT_BC2_TYPELESS","DXGI_FORMAT_BC2_UNORM","DXGI_FORMAT_BC3_TYPELESS","DXGI_FORMAT_BC3_UNORM","DXGI_FORMAT_BC1_UNORM_SRGB","DXGI_FORMAT_BC2_UNORM_SRGB","DXGI_FORMAT_BC3_UNORM_SRGB","parseDDS","header","BYTES_PER_ELEMENT","mipmapCount","pixelFormat","formatFlags","fourCC","internalFormat_1","texData","dx10Offset","dx10Header","dxgiFormat","resourceDimension","miscFlag","arraySize","internalFormat_2","DDS_DIMENSION_TEXTURE3D","imageBuffers","dataOffset","pixelSize","imageSize","max","imageOffset","FILE_IDENTIFIER","ENDIANNESS","KTX_FIELDS","GL_TYPE","GL_TYPE_SIZE","GL_FORMAT","GL_INTERNAL_FORMAT","GL_BASE_INTERNAL_FORMAT","PIXEL_WIDTH","PIXEL_HEIGHT","PIXEL_DEPTH","NUMBER_OF_ARRAY_ELEMENTS","NUMBER_OF_FACES","NUMBER_OF_MIPMAP_LEVELS","BYTES_OF_KEY_VALUE_DATA","FILE_HEADER_SIZE","TYPES_TO_BYTES_PER_COMPONENT","TYPES","FORMATS_TO_COMPONENTS","FORMATS","TYPES_TO_BYTES_PER_PIXEL","_c","parseKTX","loadKeyValueData","dataView","DataView","getUint8","validate","littleEndian","getUint32","glType","glFormat","glInternalFormat","pixelWidth","pixelHeight","pixelDepth","numberOfArrayElements","numberOfFaces","numberOfMipmapLevels","bytesOfKeyValueData","imagePixelByteSize","alignedWidth","alignedHeight","imagePixels","kvData","Map","bytesIntoKeyValueData","keyAndValueByteSize","keyAndValueByteOffset","valuePadding","keyNulByte","TextDecoder","decode","parseKvData","mipByteSize","mipWidth","mipHeight","alignedMipWidth","alignedMipHeight","mipmapLevel","elementOffset","arrayElement","mips","uncompressed","convertToInt","byteLength","convertFormatToInteger","compressed","DDSLoader","KTXLoader","kvData_1","textureId","ktxKeyValueData","textures_1","TEXT_GRADIENT","maxSize","properties","batchSize","autoResize","_properties","_maxSize","_batchSize","_buffers","_bufferUpdateIDs","_updateID","blendMode","BLEND_MODES","roundPixels","setProperties","_tint","tintRgb","tint","ParticleContainer","vertices","rotation","uvs","displayObjectUpdateTransform","hex2rgb","worldAlpha","renderable","valid","once","onChildrenChange","batch","setObjectRenderer","particle","render","smallestChildIndex","bufferIndex","dispose","Container","dynamicPropertyFlags","size","geometry","Geometry","indexBuffer","dynamicProperties","staticProperties","property","attributeName","uploadFunction","staticStride","staticBuffer","staticData","staticDataUint32","dynamicStride","dynamicBuffer","dynamicData","dynamicDataUint32","initBuffers","ParticleBuffer","dynamicOffset","Buffer","createIndicesForQuads","addIndex","dynBuffer","staticOffset","statBuffer","addAttribute","startIndex","amount","shader","tempMatrix","Matrix","uploadVertices","uploadPosition","uploadRotation","uploadUvs","uploadTint","Shader","vertex","fragment","state","State","ParticleRenderer","container","totalChildren","generateBuffers","premultiplied","correctBlendMode","m","copyTo","prepend","globalUniforms","uniforms","projectionMatrix","translationMatrix","toArray","uColor","premultiplyRgba","uSampler","updateStatic","_generateOneMoreBuffer","uploadDynamic","bid","uploadStatic","drawElements","TRIANGLES","UNSIGNED_SHORT","array","stride","w0","w1","h0","h1","sprite","trim","orig","anchor","spritePosition","spriteRotation","textureUvs","_uvs","x0","y0","x1","y1","x2","y2","x3","y3","argb","premultiplyTint","_tintRGB","ObjectRenderer","defaultStyle","align","breakWords","dropShadow","dropShadowAlpha","dropShadowAngle","PI","dropShadowBlur","dropShadowColor","dropShadowDistance","fill","fillGradientType","LINEAR_VERTICAL","fillGradientStops","fontFamily","fontSize","fontStyle","fontVariant","fontWeight","letterSpacing","lineHeight","lineJoin","miterLimit","padding","stroke","strokeThickness","textBaseline","whiteSpace","wordWrap","wordWrapWidth","leading","genericFontFamilies","styleID","deepCopyProperties","TextStyle","clonedProperties","_align","_breakWords","_dropShadow","_dropShadowAlpha","_dropShadowAngle","_dropShadowBlur","_dropShadowColor","outputColor","getColor","_dropShadowDistance","_fill","_fillGradientType","_fillGradientStops","array1","array2","areArraysEqual","_fontFamily","_fontSize","_fontStyle","_fontVariant","_fontWeight","_letterSpacing","_lineHeight","_leading","_lineJoin","_miterLimit","_padding","_stroke","_strokeThickness","_textBaseline","_trim","_whiteSpace","_wordWrap","_wordWrapWidth","fontSizeString","fontFamilies","getSingleColor","color","hex2string","propertyObj","prop","contextSettings","willReadFrequently","text","lines","lineWidths","maxLineWidth","fontProperties","TextMetrics","_canvas","font","toFontString","measureFont","ascent","lineWidth","measureText","line","cache","collapseSpaces","collapseNewlines","canPrependSpaces","tokens","tokenize","token","isNewline","addLine","currIsBreakingSpace","isBreakingSpace","lastIsBreakingSpace","tokenWidth","getFromCache","canBreakWords","characters","wordWrapSplit","char","nextChar","lastChar","canBreakChars","characterWidth","isLastToken","newLine","trimRight","spacing","_newlines","charCodeAt","_nextChar","_breakingSpaces","_token","_char","_index","_fonts","descent","_context","metricsString","METRICS_STRING","BASELINE_SYMBOL","ceil","baseline","HEIGHT_MULTIPLIER","BASELINE_MULTIPLIER","fillStyle","fillRect","fillText","imagedata","idx","stop","__canvas","c","__context","defaultDestroyOptions","ownCanvas","_ownCanvas","_resolution","_autoResolution","_text","_style","_styleListener","_font","localStyleID","Text","respectDirty","dirty","linePositionX","linePositionY","measured","clearRect","passesCount","isShadowPass","dsOffsetText","dsOffsetShadow","strokeStyle","rgb","string2hex","shadowColor","shadowBlur","shadowOffsetX","cos","shadowOffsetY","sin","_generateFillStyle","linePositionYShift","nextLineHeightBehavior","i_1","drawLetterSpacing","updateTexture","isStroke","supportLetterSpacing","experimentalLetterSpacing","CanvasRenderingContext2D","textLetterSpacing","strokeText","currentPosition","stringArray","previousWidth","currentWidth","currentChar","textStr","trimmed","trimCanvas","_frame","_onTextureUpdate","setRealSize","updateUvs","updateText","_render","updateTransform","skipUpdate","_textureID","getLocalBounds","calculateVertices","_bounds","addQuad","vertexData","metrics","gradient","dropShadowCorrection","lengthPlus1","unshift","createLinearGradient","textHeight","lastLineBottom","thisLineTop","thisLineGradientStart","thisLineBottom","nextLineTop","thisLineGradientEnd","gradStopLineHeight","lineStop","globalStop","toFixed","addColorStop","totalIterations","currentIteration","abs","Sprite","maxItemsPerFrame","itemsLeft","CountLimiter","findMultipleBaseTextures","item","queue","_textures","findBaseTexture","findTexture","drawText","_helper","calculateTextStyle","findText","findTextStyle","limiter","uploadHookHelper","addHooks","uploadHooks","completes","ticking","delayedTick","prepareItems","registerFindHook","registerUploadHook","BasePrepare","deprecation","complete","tick","beginFrame","allowedToUpload","uploaded","_destroyed","shift","addHook","uploadHook","uploadBaseTextures","_glTextures","CONTEXT_UID","uploadGraphics","Graphics","finishPoly","updateBatches","batches","batchable","_resolveDirectShader","findGraphics","Prepare","maxMilliseconds","frameStart","TimeLimiter","resolutionFilename","animations","_updateResolution","_frames","frames","_frameKeys","_batchIndex","_callback","Spritesheet","meta","getResolutionOfUrl","parseFloat","setResolution","BATCH_SIZE","_processFrames","_processAnimations","_parseComplete","_nextBatch","initialFrameIndex","frameIndex","maxFrames","sourceSize","w","h","rotated","spriteSourceSize","animName","frameName","destroyBase","linkedSheets","SpritesheetLoader","loader","imageResourceName","multiPacks","related_multi_packs","itemName","itemUrl","values","some","r","loadType","xhrType","multiPacks_1","_i","getResourcePath","spritesheet","parse","isDataUrl","tempPoint","tileTransform","Transform","uvMatrix","TextureMatrix","pluginName","uvRespectAnchor","TilingSprite","clampMargin","copyFrom","_cachedTint","updateLocalTransform","minX","_anchor","_x","minY","_y","maxX","maxY","addFrame","transform","_localBoundsRect","getRectangle","tempMat","runners","contextChange","quad","QuadUv","TilingSpriteRenderer","globals","simpleShader","gl1VertexSrc","ts","anchorX","anchorY","invalidate","tex","baseTex","lt","localTransform","uv","isSimple","isPowerOfTwo","wrapMode","WRAP_MODES","W","H","invert","mapCoord","uMapCoord","uClampFrame","uClampOffset","uTransform","premultiplyTintToRgba","draw","info","common","page","kerning","distanceField","TextFormat","txt","items","rawData","chars","kernings","attributeList","itemData","strValue","floatValue","BitmapFontData","face","parseInt","file","xoffset","yoffset","xadvance","first","second","df","distanceRange","fieldType","XMLFormat","XMLDocument","getElementsByTagName","xml","XMLStringFormat","DOMParser","parseFromString","xmlTxt","formats","autoDetectFormat","drawGlyph","translate","lastIterationStop","clampedStop","generateFillStyle","setTransform","splitTextToCharacters","extractCharCode","str","codePointAt","ownsTextures","pageTextures","_ownsTextures","page_1","xOffset","yOffset","xAdvance","distanceFieldRange","distanceFieldType","BitmapFont","fontData","available","textStyle","defaultOptions","textureWidth","textureHeight","charsList","startCode","endCode","j_1","resolveCharacters","positionX","positionY","maxCharHeight","character","textureGlyphWidth","c1","c2","uninstall","ALPHANUMERIC","pageMeshDataDefaultPageMeshData","pageMeshDataMSDFPageMeshData","charRenderDataPool","BitmapText","styleDefaults","maxWidth","fontName","_activePagesMeshData","_textWidth","_textHeight","_fontName","_maxWidth","_maxLineHeight","ObservablePoint","_roundPixels","_textureCache","pos","lineSpaces","charsInput","pageMeshDataPool","prevCharCode","lastLineWidth","lastBreakPos","lastBreakWidth","spacesRemoved","maxLineHeight","spaceCount","charCode","charData","charRenderData","prevSpaces","lineAlignOffsets","alignOffset","lenChars","pagesMeshData","newPagesMeshData","activePagesMeshData","baseTextureUid","uid","pageMeshData","MeshGeometry","material","meshBlendMode","MeshMaterial","program","Program","uFWidth","mesh","Mesh","index","indexCount","vertexCount","uvsCount","total","indices","total_1","xPos","yPos","pageMesh","textureFrame","anchorOffsetX","anchorOffsetY","i_2","vertexBuffer","getBuffer","textureBuffer","getIndex","containerUpdateTransform","dx","sqrt","dy","worldScale","fontScale","filter","BitmapFontLoader","getBaseUrl","completed","pageFile","bitmapFont","install","exists","bitmapResource","onAfterMiddleware","resUrl","dirname","charAt","dir","defaultVertex","uAlpha","AlphaFilter","Filter","vertTemplate","GAUSSIAN_VALUES","fragTemplate","BlurFilterPass","strength","kernelSize","vertSrc","template","halfLength","vertSource","blurLoop","blur","generateBlurVertSource","horizontal","fragSrc","kernel","fragSource","generateBlurFragSource","_quality","filterManager","input","output","clearMode","passes","applyFilter","renderTarget","getFilterTexture","flip","flop","blend","CLEAR_MODES","bindAndClear","temp","returnFilterTexture","blurXFilter","blurYFilter","repeatEdgePixels","BlurFilter","xStrength","yStrength","_repeatEdgePixels","updatePadding","defaultFilterVertex","ColorMatrixFilter","matrix","multiply","newMatrix","_multiply","_colorMatrix","_loadMatrix","cosR","sinR","sqrW","o","saturate","desaturation","toned","lightColor","darkColor","lR","lG","lB","dR","dG","dB","intensity","grayscale","greyscale","DisplacementFilter","maskMatrix","mapSampler","filterMatrix","maskSprite","calculateSpriteMatrix","lenX","lenY","FXAAFilter","NoiseFilter","seed","noise","random","uNoise","uSeed","_tempMatrix","textureCacheId","originalRender","originalRenderCanvas","originalCalculateBounds","originalGetLocalBounds","originalUpdateTransform","originalDestroy","originalMask","originalFilterArea","originalContainsPoint","defineProperties","cacheAsBitmapResolution","_cacheAsBitmapResolution","cacheAsBitmap","cacheAsBitmapMultisample","_cacheAsBitmapMultisample","_cacheAsBitmap","_cacheData","CacheData","renderCanvas","calculateBounds","filterArea","_renderCached","_renderCachedCanvas","_cacheAsBitmapDestroy","_destroyCachedDisplayObject","_initCachedDisplayObject","_worldID","cacheAlpha","flush","bounds","clone","filters","pad","cachedRenderTexture","current","cachedSourceFrame","sourceFrame","cachedDestinationFrame","destinationFrame","cachedProjectionTransform","projection","clear","skipUpdateTransform","_calculateCachedBounds","_getCachedLocalBounds","cachedSprite","_parentID","enableTempParent","disableTempParent","_initCachedDisplayObjectCanvas","_renderCanvas","cachedRenderTarget","_projTransform","_tempDisplayObjectParent","_calculateBounds","updateID","_boundsID","deep","getChildByName","toGlobal","ResizePlugin","defineProperty","dom","queueResize","_resizeTo","resize","cancelResize","_resizeId","window","innerWidth","innerHeight","resizeTo","stage","forceCanvas","autoDetectRenderer","Application","_plugins","plugin","init","ref","screen","removeView","stageOptions","reverse","AnimatedSprite","autoUpdate","_durations","_autoUpdate","_isConnectedToTicker","animationSpeed","loop","updateAnchor","onComplete","onFrameChange","onLoop","_currentTime","_playing","_previousFrame","frameNumber","previousFrame","currentFrame","play","elapsed","lag","gotoAndStop","_textureTrimmedID","uvsFloat32","defaultAnchor","images","time","BatchRenderer","TickerPlugin","AppLoaderPlugin","CanvasMaskManager","maskData","save","foundShapes","_foundShapes","recursiveFindShapes","beginPath","shape","setContextTransform","renderGraphicsShape","clip","graphicsData","graphics","SHAPES","points","holes","outerArea","innerArea","px","py","moveTo","lineTo","closeStroke","closePath","arc","radius","kappa","ox","oy","xe","ye","xm","ym","bezierCurveTo","rx","ry","maxRadius","quadraticCurveTo","restore","invalidateBlendMode","createColoredCanvas","canUseNewCanvasBlendModes","magenta","yellow","globalCompositeOperation","imageData","RENDERER_TYPE","rootContext","useContextAlpha","imageSmoothingEnabled","rc","webkitImageSmoothingEnabled","smoothProperty","mozImageSmoothingEnabled","oImageSmoothingEnabled","msImageSmoothingEnabled","initPlugins","CanvasRenderer","__plugins","sayHello","BaseRenderTexture","rootResolution","castToBaseTexture","_canvasRenderTarget","CanvasResource","cacheParent","globalAlpha","_activeBlendMode","_outerBlend","blendModes","clearBeforeRender","backgroundAlpha","_backgroundColorString","clearColor","rgb2hex","realWidth","realHeight","tempContext","localResolution","mat","proj","readyForOuterBlend","outerBlend","refresh","maskManager","desiredScreenWidth","desiredScreenHeight","SCALE_MODES","ctor","AbstractRenderer","canvasUtils","getTintedCanvas","stringColor","roundColor","tintCache","cachedCanvas","tintId","tintMethod","convertTintToImage","tintImage","getTintedPattern","patternCache","pattern","createPattern","tintWithMultiply","crop","getDrawableSource","tintWithOverlay","tintWithPerPixel","rgbValues","pixelData","cacheStepsPerColorChannel","canUseMultiply","parentCreate","Renderer","bitmap","CanvasMeshRenderer","setBlendMode","drawMode","DRAW_MODES","_renderTriangleMesh","_renderTriangles","_renderDrawTriangle","index0","index1","index2","isTinted","base","_cachedTexture","_tintedCanvas","textureSource","u0","u1","u2","v0","v1","v2","screenPadding","canvasPadding","centerX","centerY","normX","normY","screenX","screenY","screenDist","paddingFactor","delta","deltaA","deltaB","deltaC","deltaD","deltaE","deltaF","NineSlicePlane","_canvasUvs","_leftWidth","_rightWidth","_topHeight","_bottomHeight","row","col","ind","sw","sh","dw","dh","warned","calculateUvs","_canvasPadding","SimpleMesh","SimpleRope","canvasRenderer","PolygonUtils","offsetPoints","isPolygonClockwise","v1x","v1y","norm1x","norm1y","pij1","pij2","v2x","v2y","norm2x","norm2y","pjk1","pjk2","intersectPoint","findIntersection","x4","y4","denominator","numeratorA","uA","polygon","sum","CanvasGraphicsRenderer","setPatternTransform","contextFillStyle","contextStrokeStyle","tintR","tintG","tintB","lineStyle","fillColor","lineColor","append","fillTint","_calcCanvasStyle","lineTint","lineCap","cap","tempShape","holesDirection","paintPolygonStroke","alignmentOffset","alignment","strokeRect","drawShapeOverStroke","paintEllipse","sW","sH","sX","sY","sOx","sOy","sXe","sYe","sXm","sYm","paintRoundedRectangle","sRx","sRy","sWidth","sHeight","radiusOffset","sRadius","sMaxRadius","offsetPolygon","_svgMatrix","svg","createElementNS","createSVGMatrix","inverse","scaleMode","isMask","canvasRenderWorldTransform","CanvasSpriteRenderer","sourceWidth","sourceHeight","destWidth","destHeight","groupD8","rotate","smoothingEnabled","CanvasExtract","CANVAS_START_SIZE","prepare","tempPrepare","ctx","CanvasPrepare","worldMatrix","patternMatrix","patternRect","baseTextureResolution","tempCanvas","_canvasPattern","identity","tileScale","lx","ly","isRotated","finalWidth","finalHeight","childTransform","_renderer","pushMask","popMask"],"sourceRoot":""}