@visactor/vtable
Version:
canvas table width high performance
1,176 lines (1,127 loc) • 4.61 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VTable = {}));
})(this, (function (exports) { 'use strict';
class Generator {
static GenAutoIncrementId() {
return Generator.auto_increment_id++;
}
}
Generator.auto_increment_id = 0;
class ContainerModule {
constructor(registry) {
this.id = Generator.GenAutoIncrementId(), this.registry = registry;
}
}
const NAMED_TAG = "named";
const INJECT_TAG = "inject";
const MULTI_INJECT_TAG = "multi_inject";
const TAGGED = "inversify:tagged";
const PARAM_TYPES = "inversify:paramtypes";
class Metadata {
constructor(key, value) {
this.key = key, this.value = value;
}
toString() {
return this.key === NAMED_TAG ? `named: ${String(this.value).toString()} ` : `tagged: { key:${this.key.toString()}, value: ${String(this.value)} }`;
}
}
var Reflect$1 = (function (Reflect) {
var target;
return function (exporter) {
const supportsSymbol = "function" == typeof Symbol,
toPrimitiveSymbol = supportsSymbol && void 0 !== Symbol.toPrimitive ? Symbol.toPrimitive : "@@toPrimitive",
functionPrototype = (Object.getPrototypeOf(Function)),
_Map = ("object" == typeof process && process.env && process.env.REFLECT_METADATA_USE_MAP_POLYFILL, Map),
Metadata = (new WeakMap());
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
function hasMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryHasMetadata(metadataKey, target, propertyKey);
}
function hasOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
}
function getMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target)) throw new TypeError();
return IsUndefined(propertyKey) || (propertyKey = ToPropertyKey(propertyKey)), OrdinaryGetMetadata(metadataKey, target, propertyKey);
}
function GetOrCreateMetadataMap(O, P, Create) {
let targetMetadata = Metadata.get(O);
if (IsUndefined(targetMetadata)) {
if (!Create) return;
targetMetadata = new _Map(), Metadata.set(O, targetMetadata);
}
let metadataMap = targetMetadata.get(P);
if (IsUndefined(metadataMap)) {
if (!Create) return;
metadataMap = new _Map(), targetMetadata.set(P, metadataMap);
}
return metadataMap;
}
function OrdinaryHasMetadata(MetadataKey, O, P) {
if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return !0;
const parent = OrdinaryGetPrototypeOf(O);
return !IsNull(parent) && OrdinaryHasMetadata(MetadataKey, parent, P);
}
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
const metadataMap = GetOrCreateMetadataMap(O, P, !1);
return !IsUndefined(metadataMap) && ToBoolean(metadataMap.has(MetadataKey));
}
function OrdinaryGetMetadata(MetadataKey, O, P) {
if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
const parent = OrdinaryGetPrototypeOf(O);
return IsNull(parent) ? void 0 : OrdinaryGetMetadata(MetadataKey, parent, P);
}
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
const metadataMap = GetOrCreateMetadataMap(O, P, !1);
if (!IsUndefined(metadataMap)) return metadataMap.get(MetadataKey);
}
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
GetOrCreateMetadataMap(O, P, !0).set(MetadataKey, MetadataValue);
}
function Type(x) {
if (null === x) return 1;
switch (typeof x) {
case "undefined":
return 0;
case "boolean":
return 2;
case "string":
return 3;
case "symbol":
return 4;
case "number":
return 5;
case "object":
return null === x ? 1 : 6;
default:
return 6;
}
}
function IsUndefined(x) {
return void 0 === x;
}
function IsNull(x) {
return null === x;
}
function IsSymbol(x) {
return "symbol" == typeof x;
}
function IsObject(x) {
return "object" == typeof x ? null !== x : "function" == typeof x;
}
function ToPrimitive(input, PreferredType) {
switch (Type(input)) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
return input;
}
const hint = 3 === PreferredType ? "string" : 5 === PreferredType ? "number" : "default",
exoticToPrim = GetMethod(input, toPrimitiveSymbol);
if (void 0 !== exoticToPrim) {
const result = exoticToPrim.call(input, hint);
if (IsObject(result)) throw new TypeError();
return result;
}
return OrdinaryToPrimitive(input, "default" === hint ? "number" : hint);
}
function OrdinaryToPrimitive(O, hint) {
if ("string" === hint) {
const toString_1 = O.toString;
if (IsCallable(toString_1)) {
const result = toString_1.call(O);
if (!IsObject(result)) return result;
}
const valueOf = O.valueOf;
if (IsCallable(valueOf)) {
const result = valueOf.call(O);
if (!IsObject(result)) return result;
}
} else {
const valueOf = O.valueOf;
if (IsCallable(valueOf)) {
const result = valueOf.call(O);
if (!IsObject(result)) return result;
}
const toString_2 = O.toString;
if (IsCallable(toString_2)) {
const result = toString_2.call(O);
if (!IsObject(result)) return result;
}
}
throw new TypeError();
}
function ToBoolean(argument) {
return !!argument;
}
function ToString(argument) {
return "" + argument;
}
function ToPropertyKey(argument) {
const key = ToPrimitive(argument, 3);
return IsSymbol(key) ? key : ToString(key);
}
function IsCallable(argument) {
return "function" == typeof argument;
}
function GetMethod(V, P) {
const func = V[P];
if (null != func) {
if (!IsCallable(func)) throw new TypeError();
return func;
}
}
function OrdinaryGetPrototypeOf(O) {
const proto = Object.getPrototypeOf(O);
if ("function" != typeof O || O === functionPrototype) return proto;
if (proto !== functionPrototype) return proto;
const prototype = O.prototype,
prototypeProto = prototype && Object.getPrototypeOf(prototype);
if (null == prototypeProto || prototypeProto === Object.prototype) return proto;
const constructor = prototypeProto.constructor;
return "function" != typeof constructor || constructor === O ? proto : constructor;
}
exporter("defineMetadata", defineMetadata), exporter("hasMetadata", hasMetadata), exporter("hasOwnMetadata", hasOwnMetadata), exporter("getMetadata", getMetadata);
}((target = Reflect, function (key, value) {
"function" != typeof target[key] && Object.defineProperty(target, key, {
configurable: !0,
writable: !0,
value: value
});
})), Reflect;
})({});
function _tagParameterOrProperty(metadataKey, annotationTarget, key, metadata) {
const metadatas = [metadata];
let paramsOrPropertiesMetadata = {};
Reflect$1.hasOwnMetadata(metadataKey, annotationTarget) && (paramsOrPropertiesMetadata = Reflect$1.getMetadata(metadataKey, annotationTarget));
let paramOrPropertyMetadata = paramsOrPropertiesMetadata[key];
void 0 === paramOrPropertyMetadata && (paramOrPropertyMetadata = []), paramOrPropertyMetadata.push(...metadatas), paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata, Reflect$1.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
}
function tagParameter(annotationTarget, parameterName, parameterIndex, metadata) {
_tagParameterOrProperty(TAGGED, annotationTarget, parameterIndex.toString(), metadata);
}
function createTaggedDecorator(metadata) {
return (target, targetKey, indexOrPropertyDescriptor) => {
tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
};
}
function injectBase(metadataKey) {
return serviceIdentifier => (target, targetKey, indexOrPropertyDescriptor) => createTaggedDecorator(new Metadata(metadataKey, serviceIdentifier))(target, targetKey, indexOrPropertyDescriptor);
}
const inject = injectBase(INJECT_TAG);
const multiInject = injectBase(MULTI_INJECT_TAG);
function injectable() {
return function (target) {
return Reflect$1.defineMetadata(PARAM_TYPES, null, target), target;
};
}
function named(name) {
return createTaggedDecorator(new Metadata(NAMED_TAG, name));
}
const BindingScopeEnum = {
Singleton: "Singleton",
Transient: "Transient"
},
BindingTypeEnum = {
ConstantValue: "ConstantValue",
Constructor: "Constructor",
DynamicValue: "DynamicValue",
Factory: "Factory",
Function: "Function",
Instance: "Instance",
Invalid: "Invalid",
Provider: "Provider"
};
class Binding {
constructor(serviceIdentifier, scope) {
this.id = Generator.GenAutoIncrementId(), this.activated = !1, this.serviceIdentifier = serviceIdentifier, this.scope = scope, this.type = BindingTypeEnum.Invalid, this.constraint = request => !0, this.implementationType = null, this.cache = null, this.factory = null, this.provider = null, this.dynamicValue = null;
}
clone() {
const clone = new Binding(this.serviceIdentifier, this.scope);
return clone.activated = clone.scope === BindingScopeEnum.Singleton && this.activated, clone.implementationType = this.implementationType, clone.dynamicValue = this.dynamicValue, clone.scope = this.scope, clone.type = this.type, clone.provider = this.provider, clone.constraint = this.constraint, clone.cache = this.cache, clone;
}
}
class MetadataReader {
getConstructorMetadata(constructorFunc) {
return {
compilerGeneratedMetadata: Reflect$1.getMetadata(PARAM_TYPES, constructorFunc),
userGeneratedMetadata: Reflect$1.getMetadata(TAGGED, constructorFunc) || {}
};
}
getPropertiesMetadata(constructorFunc) {
throw new Error("暂未实现");
}
}
const taggedConstraint = key => value => {
const constraint = request => {
if (null == request) return !1;
if (request.key === key && request.value === value) return !0;
if (null == request.constructorArgsMetadata) return !1;
const constructorArgsMetadata = request.constructorArgsMetadata;
for (let i = 0; i < constructorArgsMetadata.length; i++) if (constructorArgsMetadata[i].key === key && constructorArgsMetadata[i].value === value) return !0;
return !1;
};
return constraint.metaData = new Metadata(key, value), constraint;
};
const namedConstraint = taggedConstraint(NAMED_TAG);
class BindingInSyntax {
constructor(binding) {
this._binding = binding;
}
inRequestScope() {
throw new Error("暂未实现");
}
inSingletonScope() {
return this._binding.scope = BindingScopeEnum.Singleton, this;
}
inTransientScope() {
return this._binding.scope = BindingScopeEnum.Transient, this;
}
whenTargetNamed(name) {
return this._binding.constraint = namedConstraint(name), this;
}
}
class BindingToSyntax {
constructor(binding) {
this._binding = binding;
}
to(constructor) {
return this._binding.type = BindingTypeEnum.Instance, this._binding.implementationType = constructor, new BindingInSyntax(this._binding);
}
toSelf() {
const self = this._binding.serviceIdentifier;
return this.to(self);
}
toDynamicValue(func) {
return this._binding.type = BindingTypeEnum.DynamicValue, this._binding.cache = null, this._binding.dynamicValue = func, this._binding.implementationType = null, new BindingInSyntax(this._binding);
}
toConstantValue(value) {
return this._binding.type = BindingTypeEnum.ConstantValue, this._binding.cache = value, this._binding.dynamicValue = null, this._binding.implementationType = null, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
}
toFactory(factory) {
return this._binding.type = BindingTypeEnum.Factory, this._binding.factory = factory, this._binding.scope = BindingScopeEnum.Singleton, new BindingInSyntax(this._binding);
}
toService(service) {
this.toDynamicValue(context => context.container.get(service));
}
}
let Container$2 = class Container {
constructor(containerOptions) {
const options = containerOptions || {};
options.defaultScope = options.defaultScope || BindingScopeEnum.Transient, this.options = options, this.id = Generator.GenAutoIncrementId(), this._bindingDictionary = new Map(), this._metadataReader = new MetadataReader();
}
load(module) {
const containerModuleHelpers = this._getContainerModuleHelpersFactory()(module.id);
module.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
}
get(serviceIdentifier) {
const getArgs = this._getNotAllArgs(serviceIdentifier, !1);
return this._get(getArgs);
}
getAll(serviceIdentifier) {
const getArgs = this._getAllArgs(serviceIdentifier);
return this._get(getArgs);
}
getTagged(serviceIdentifier, key, value) {
const getArgs = this._getNotAllArgs(serviceIdentifier, !1, key, value);
return this._get(getArgs);
}
getNamed(serviceIdentifier, named) {
return this.getTagged(serviceIdentifier, NAMED_TAG, named);
}
isBound(serviceIdentifier) {
return this._bindingDictionary.has(serviceIdentifier);
}
bind(serviceIdentifier) {
const scope = this.options.defaultScope,
binding = new Binding(serviceIdentifier, scope),
list = this._bindingDictionary.get(serviceIdentifier) || [];
return list.push(binding), this._bindingDictionary.set(serviceIdentifier, list), new BindingToSyntax(binding);
}
unbind(serviceIdentifier) {
this._bindingDictionary.delete(serviceIdentifier);
}
rebind(serviceIdentifier) {
return this.unbind(serviceIdentifier), this.bind(serviceIdentifier);
}
_getContainerModuleHelpersFactory() {
const setModuleId = (bindingToSyntax, moduleId) => {
bindingToSyntax._binding.moduleId = moduleId;
},
getBindFunction = moduleId => serviceIdentifier => {
const bindingToSyntax = this.bind(serviceIdentifier);
return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
},
getUnbindFunction = () => serviceIdentifier => this.unbind(serviceIdentifier),
getIsboundFunction = () => serviceIdentifier => this.isBound(serviceIdentifier),
getRebindFunction = moduleId => serviceIdentifier => {
const bindingToSyntax = this.rebind(serviceIdentifier);
return setModuleId(bindingToSyntax, moduleId), bindingToSyntax;
};
return mId => ({
bindFunction: getBindFunction(mId),
isboundFunction: getIsboundFunction(),
rebindFunction: getRebindFunction(mId),
unbindFunction: getUnbindFunction(),
unbindAsyncFunction: serviceIdentifier => null
});
}
_getNotAllArgs(serviceIdentifier, isMultiInject, key, value) {
return {
avoidConstraints: !1,
isMultiInject: isMultiInject,
serviceIdentifier: serviceIdentifier,
key: key,
value: value
};
}
_getAllArgs(serviceIdentifier) {
return {
avoidConstraints: !0,
isMultiInject: !0,
serviceIdentifier: serviceIdentifier
};
}
_get(getArgs) {
const result = [];
return this._bindingDictionary.get(getArgs.serviceIdentifier).filter(b => b.constraint(getArgs)).forEach(binding => {
result.push(this._resolveFromBinding(binding));
}), getArgs.isMultiInject || 1 !== result.length ? result : result[0];
}
_getChildRequest(binding) {
const constr = binding.implementationType,
{
userGeneratedMetadata: userGeneratedMetadata
} = this._metadataReader.getConstructorMetadata(constr),
keys = Object.keys(userGeneratedMetadata),
arr = [];
for (let i = 0; i < keys.length; i++) {
const constructorArgsMetadata = userGeneratedMetadata[i],
targetMetadataMap = {};
constructorArgsMetadata.forEach(md => {
targetMetadataMap[md.key] = md.value;
});
const metadata = {
inject: targetMetadataMap[INJECT_TAG],
multiInject: targetMetadataMap[MULTI_INJECT_TAG]
},
injectIdentifier = metadata.inject || metadata.multiInject,
target = {
serviceIdentifier: injectIdentifier,
constructorArgsMetadata: constructorArgsMetadata
},
bindings = (this._bindingDictionary.get(injectIdentifier) || []).filter(b => b.constraint(target));
if (bindings.length) {
const request = {
injectIdentifier: injectIdentifier,
metadata: constructorArgsMetadata,
bindings: bindings
};
arr.push(request);
}
}
return arr;
}
_resolveFromBinding(binding) {
const result = this._getResolvedFromBinding(binding);
return this._saveToScope(binding, result), result;
}
_getResolvedFromBinding(binding) {
let result;
switch (binding.type) {
case BindingTypeEnum.ConstantValue:
case BindingTypeEnum.Function:
result = binding.cache;
break;
case BindingTypeEnum.Instance:
result = this._resolveInstance(binding, binding.implementationType);
break;
default:
result = binding.dynamicValue({
container: this
});
}
return result;
}
_resolveInstance(binding, constr) {
if (binding.activated) return binding.cache;
const childRequests = this._getChildRequest(binding);
return this._createInstance(constr, childRequests);
}
_createInstance(constr, childRequests) {
if (childRequests.length) {
return new constr(...this._resolveRequests(childRequests));
}
return new constr();
}
_resolveRequests(childRequests) {
return childRequests.map(request => request.bindings.length > 1 ? request.bindings.map(binding => this._resolveFromBinding(binding)) : this._resolveFromBinding(request.bindings[0]));
}
_saveToScope(binding, result) {
binding.scope === BindingScopeEnum.Singleton && (binding.cache = result, binding.activated = !0);
}
};
const ContributionProvider = Symbol("ContributionProvider");
class ContributionProviderCache {
constructor(serviceIdentifier, container) {
this.serviceIdentifier = serviceIdentifier, this.container = container, ContributionStore.setStore(this.serviceIdentifier, this);
}
getContributions() {
return this.caches || (this.caches = [], this.container && this.container.isBound(this.serviceIdentifier) && this.caches.push(...this.container.getAll(this.serviceIdentifier))), this.caches;
}
refresh() {
this.caches && (this.caches.length = 0, this.container && this.container.isBound(this.serviceIdentifier) && this.caches.push(...this.container.getAll(this.serviceIdentifier)));
}
}
function bindContributionProvider(bind, id) {
bind(ContributionProvider).toDynamicValue(({
container: container
}) => new ContributionProviderCache(id, container)).inSingletonScope().whenTargetNamed(id);
}
function bindContributionProviderNoSingletonScope(bind, id) {
bind(ContributionProvider).toDynamicValue(({
container: container
}) => new ContributionProviderCache(id, container)).whenTargetNamed(id);
}
class ContributionStore {
static getStore(id) {
return this.store.get(id);
}
static setStore(id, cache) {
this.store.set(id, cache);
}
static refreshAllContributions() {
this.store.forEach(cache => {
cache.refresh();
});
}
}
ContributionStore.store = new Map();
class Hook {
constructor(args, name) {
this._args = args, this.name = name, this.taps = [];
}
tap(options, fn) {
this._tap("sync", options, fn);
}
unTap(options, fn) {
const name = "string" == typeof options ? options.trim() : options.name;
name && (this.taps = this.taps.filter(tap => !(tap.name === name && (!fn || tap.fn === fn))));
}
_parseOptions(type, options, fn) {
let _options;
if ("string" == typeof options) _options = {
name: options.trim()
};else if ("object" != typeof options || null === options) throw new Error("Invalid tap options");
if ("string" != typeof _options.name || "" === _options.name) throw new Error("Missing name for tap");
return _options = Object.assign({
type: type,
fn: fn
}, _options), _options;
}
_tap(type, options, fn) {
this._insert(this._parseOptions(type, options, fn));
}
_insert(item) {
let before;
"string" == typeof item.before ? before = new Set([item.before]) : Array.isArray(item.before) && (before = new Set(item.before));
let stage = 0;
"number" == typeof item.stage && (stage = item.stage);
let i = this.taps.length;
for (; i > 0;) {
i--;
const x = this.taps[i];
this.taps[i + 1] = x;
const xStage = x.stage || 0;
if (before) {
if (before.has(x.name)) {
before.delete(x.name);
continue;
}
if (before.size > 0) continue;
}
if (!(xStage > stage)) {
i++;
break;
}
}
this.taps[i] = item;
}
}
class SyncHook extends Hook {
call(...args) {
this.taps.map(t => t.fn).forEach(cb => cb(...args));
}
}
const EnvContribution = Symbol.for("EnvContribution");
const VGlobal = Symbol.for("VGlobal");
const DEFAULT_TEXT_FONT_FAMILY$2 = "PingFang SC,Helvetica Neue,Microsoft Yahei,system-ui,'-apple-system',segoe ui,Roboto,Helvetica,Arial,sans-serif,apple color emoji,segoe ui emoji,segoe ui symbol";
const container = new Container$2();
const RenderService = Symbol.for("RenderService");
class Application {
get renderService() {
return this._renderService || (this._renderService = container.get(RenderService)), this._renderService;
}
}
const application = new Application();
let idx = 0;
class PerformanceRAF {
constructor() {
this.nextAnimationFrameCbs = new Map(), this._rafHandle = null, this.runAnimationFrame = time => {
this._rafHandle = null;
const cbs = this.nextAnimationFrameCbs;
this.nextAnimationFrameCbs = new Map(), cbs.forEach(cb => cb(time));
}, this.tryRunAnimationFrameNextFrame = () => {
null === this._rafHandle && 0 !== this.nextAnimationFrameCbs.size && (this._rafHandle = application.global.getRequestAnimationFrame()(this.runAnimationFrame));
};
}
addAnimationFrameCb(callback) {
return this.nextAnimationFrameCbs.set(++idx, callback), this.tryRunAnimationFrameNextFrame(), idx;
}
removeAnimationFrameCb(index) {
return !!this.nextAnimationFrameCbs.has(index) && (this.nextAnimationFrameCbs.delete(index), !0);
}
}
class EventListenerManager {
constructor() {
this._listenerMap = new Map(), this._eventListenerTransformer = event => event;
}
setEventListenerTransformer(transformer) {
this._eventListenerTransformer = transformer || (event => event);
}
addEventListener(type, listener, options) {
if (!listener) return;
const capture = this._resolveCapture(options),
once = this._resolveOnce(options),
listenerTypeMap = this._getOrCreateListenerTypeMap(type),
wrappedMap = this._getOrCreateWrappedMap(listenerTypeMap, listener);
if (wrappedMap.has(capture)) return;
const wrappedListener = event => {
const transformedEvent = this._eventListenerTransformer(event);
"function" == typeof listener ? listener(transformedEvent) : listener.handleEvent && listener.handleEvent(transformedEvent), once && this._deleteListenerRecord(type, listener, capture);
};
wrappedMap.set(capture, {
wrappedListener: wrappedListener,
options: options
}), this._nativeAddEventListener(type, wrappedListener, options);
}
removeEventListener(type, listener, options) {
var _a, _b;
if (!listener) return;
const capture = this._resolveCapture(options),
wrappedRecord = null === (_b = null === (_a = this._listenerMap.get(type)) || void 0 === _a ? void 0 : _a.get(listener)) || void 0 === _b ? void 0 : _b.get(capture);
wrappedRecord && (this._nativeRemoveEventListener(type, wrappedRecord.wrappedListener, capture), this._deleteListenerRecord(type, listener, capture));
}
dispatchEvent(event) {
return this._nativeDispatchEvent(event);
}
clearAllEventListeners() {
this._listenerMap.forEach((listenerMap, type) => {
listenerMap.forEach(wrappedMap => {
wrappedMap.forEach((wrappedRecord, capture) => {
this._nativeRemoveEventListener(type, wrappedRecord.wrappedListener, capture);
});
});
}), this._listenerMap.clear();
}
_resolveCapture(options) {
return "boolean" == typeof options ? options : !!(null == options ? void 0 : options.capture);
}
_resolveOnce(options) {
return "object" == typeof options && !!(null == options ? void 0 : options.once);
}
_getOrCreateListenerTypeMap(type) {
let listenerTypeMap = this._listenerMap.get(type);
return listenerTypeMap || (listenerTypeMap = new Map(), this._listenerMap.set(type, listenerTypeMap)), listenerTypeMap;
}
_getOrCreateWrappedMap(listenerTypeMap, listener) {
let wrappedMap = listenerTypeMap.get(listener);
return wrappedMap || (wrappedMap = new Map(), listenerTypeMap.set(listener, wrappedMap)), wrappedMap;
}
_deleteListenerRecord(type, listener, capture) {
const listenerTypeMap = this._listenerMap.get(type);
if (!listenerTypeMap) return;
const wrappedMap = listenerTypeMap.get(listener);
wrappedMap && (wrappedMap.delete(capture), 0 === wrappedMap.size && listenerTypeMap.delete(listener), 0 === listenerTypeMap.size && this._listenerMap.delete(type));
}
_nativeAddEventListener(type, listener, options) {
throw new Error("_nativeAddEventListener must be implemented by derived classes");
}
_nativeRemoveEventListener(type, listener, options) {
throw new Error("_nativeRemoveEventListener must be implemented by derived classes");
}
_nativeDispatchEvent(event) {
throw new Error("_nativeDispatchEvent must be implemented by derived classes");
}
}
var __decorate$11 = undefined && undefined.__decorate || function (decorators, target, key, desc) {
var d,
c = arguments.length,
r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) (d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
return c > 3 && r && Object.defineProperty(target, key, r), r;
},
__metadata$O = undefined && undefined.__metadata || function (k, v) {
if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
},
__param$B = undefined && undefined.__param || function (paramIndex, decorator) {
return function (target, key) {
decorator(target, key, paramIndex);
};
},
__awaiter$5 = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
}
function step(result) {
var value;
result.done ? resolve(result.value) : (value = result.value, value instanceof P ? value : new P(function (resolve) {
resolve(value);
})).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
let DefaultGlobal = class extends EventListenerManager {
get env() {
return this._env;
}
get isImageAnonymous() {
return this._isImageAnonymous;
}
set isImageAnonymous(isImageAnonymous) {
this._isImageAnonymous = isImageAnonymous;
}
get devicePixelRatio() {
return this._env || this.setEnv("browser"), this.envContribution.getDevicePixelRatio();
}
get supportEvent() {
return this._env || this.setEnv("browser"), this.envContribution.supportEvent;
}
set supportEvent(support) {
this._env || this.setEnv("browser"), this.envContribution.supportEvent = support;
}
get supportsTouchEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsTouchEvents;
}
set supportsTouchEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsTouchEvents = support;
}
get supportsPointerEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsPointerEvents;
}
set supportsPointerEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsPointerEvents = support;
}
get supportsMouseEvents() {
return this._env || this.setEnv("browser"), this.envContribution.supportsMouseEvents;
}
set supportsMouseEvents(support) {
this._env || this.setEnv("browser"), this.envContribution.supportsMouseEvents = support;
}
get applyStyles() {
return this._env || this.setEnv("browser"), this.envContribution.applyStyles;
}
set applyStyles(support) {
this._env || this.setEnv("browser"), this.envContribution.applyStyles = support;
}
constructor(contributions) {
super(), this.contributions = contributions, this._isImageAnonymous = !0, this._performanceRAFList = [], this.eventListenerTransformer = event => event, this.id = Generator.GenAutoIncrementId(), this.hooks = {
onSetEnv: new SyncHook(["lastEnv", "env", "global"])
}, this.measureTextMethod = "native", this.optimizeVisible = !1;
}
_nativeAddEventListener(type, listener, options) {
return this._env || this.setEnv("browser"), this.envContribution.addEventListener(type, listener, options);
}
_nativeRemoveEventListener(type, listener, options) {
return this._env || this.setEnv("browser"), this.envContribution.removeEventListener(type, listener, options);
}
_nativeDispatchEvent(event) {
return this._env || this.setEnv("browser"), this.envContribution.dispatchEvent(event);
}
bindContribution(params) {
const promiseArr = [];
if (this.contributions.getContributions().forEach(contribution => {
const data = contribution.configure(this, params);
data && data.then && promiseArr.push(data);
}), promiseArr.length) return Promise.all(promiseArr);
}
getDynamicCanvasCount() {
return this._env || this.setEnv("browser"), this.envContribution.getDynamicCanvasCount();
}
getStaticCanvasCount() {
return this._env || this.setEnv("browser"), this.envContribution.getStaticCanvasCount();
}
setEnv(env, params) {
if (params && !0 === params.force || this._env !== env) return this.deactiveCurrentEnv(), this.activeEnv(env, params);
}
deactiveCurrentEnv() {
this.envContribution && this.envContribution.release();
}
activeEnv(env, params) {
const lastEnv = this._env;
this._env = env;
const data = this.bindContribution(params);
if (data && data.then) return data.then(() => {
this.envParams = params, this.hooks.onSetEnv.call(lastEnv, env, this);
});
this.envParams = params, this.hooks.onSetEnv.call(lastEnv, env, this);
}
setActiveEnvContribution(contribution) {
this.envContribution = contribution;
}
createCanvas(params) {
return this._env || this.setEnv("browser"), this.envContribution.createCanvas(params);
}
createOffscreenCanvas(params) {
return this._env || this.setEnv("browser"), this.envContribution.createOffscreenCanvas(params);
}
releaseCanvas(canvas) {
return this._env || this.setEnv("browser"), this.envContribution.releaseCanvas(canvas);
}
getRequestAnimationFrame() {
return this._env || this.setEnv("browser"), this.envContribution.getRequestAnimationFrame();
}
getSpecifiedRequestAnimationFrame(id) {
this._env || this.setEnv("browser"), this._performanceRAFList[id] || (this._performanceRAFList[id] = new PerformanceRAF());
const performanceRAF = this._performanceRAFList[id];
return callback => performanceRAF.addAnimationFrameCb(callback);
}
getSpecifiedCancelAnimationFrame(id) {
if (this._env || this.setEnv("browser"), !this._performanceRAFList[id]) return () => !1;
const performanceRAF = this._performanceRAFList[id];
return handle => performanceRAF.removeAnimationFrameCb(handle);
}
getCancelAnimationFrame() {
return this._env || this.setEnv("browser"), this.envContribution.getCancelAnimationFrame();
}
getElementById(str) {
return this._env || this.setEnv("browser"), this.envContribution.getElementById ? this.envContribution.getElementById(str) : null;
}
getRootElement() {
return this._env || this.setEnv("browser"), this.envContribution.getRootElement ? this.envContribution.getRootElement() : null;
}
getDocument() {
return this._env || this.setEnv("browser"), this.envContribution.getDocument ? this.envContribution.getDocument() : null;
}
mapToCanvasPoint(event, domElement) {
return this._env || this.setEnv("browser"), this.envContribution.mapToCanvasPoint ? this.envContribution.mapToCanvasPoint(event, domElement) : null;
}
loadImage(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadImage(url);
}
loadSvg(str) {
return this._env || this.setEnv("browser"), this.envContribution.loadSvg(str);
}
loadJson(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadJson(url);
}
loadArrayBuffer(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadArrayBuffer(url);
}
loadBlob(url) {
return this._env || this.setEnv("browser"), this.envContribution.loadBlob(url);
}
loadFont(name, source, descriptors) {
return __awaiter$5(this, void 0, void 0, function* () {
return this._env || this.setEnv("browser"), this.envContribution.loadFont(name, source, descriptors);
});
}
isChrome() {
return null != this._isChrome || (this._env || this.setEnv("browser"), this._isChrome = "browser" === this._env && navigator.userAgent.indexOf("Chrome") > -1), this._isChrome;
}
isSafari() {
return null != this._isSafari || (this._env || this.setEnv("browser"), this._isSafari = "browser" === this._env && /Safari/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent)), this._isSafari;
}
getNativeAABBBounds(dom) {
return this._env || this.setEnv("browser"), this.envContribution.getNativeAABBBounds(dom);
}
removeDom(dom) {
return this._env || this.setEnv("browser"), this.envContribution.removeDom(dom);
}
createDom(params) {
return this._env || this.setEnv("browser"), this.envContribution.createDom(params);
}
updateDom(dom, params) {
return this._env || this.setEnv("browser"), this.envContribution.updateDom(dom, params);
}
getElementTop(dom, baseWindow = !1) {
return this._env || this.setEnv("browser"), this.envContribution.getElementTop(dom, baseWindow);
}
getElementLeft(dom, baseWindow = !1) {
return this._env || this.setEnv("browser"), this.envContribution.getElementLeft(dom, baseWindow);
}
getElementTopLeft(dom, baseWindow = !1) {
return this._env || this.setEnv("browser"), this.envContribution.getElementTopLeft(dom, baseWindow);
}
isMacOS() {
return this._env || this.setEnv("browser"), this.envContribution.isMacOS();
}
copyToClipBoard(text) {
return this._env || this.setEnv("browser"), this.envContribution.copyToClipBoard(text);
}
};
DefaultGlobal = __decorate$11([injectable(), __param$B(0, inject(ContributionProvider)), __param$B(0, named(EnvContribution)), __metadata$O("design:paramtypes", [Object])], DefaultGlobal);
var MeasureModeEnum;
!function (MeasureModeEnum) {
MeasureModeEnum[MeasureModeEnum.estimate = 0] = "estimate", MeasureModeEnum[MeasureModeEnum.actualBounding = 1] = "actualBounding", MeasureModeEnum[MeasureModeEnum.fontBounding = 2] = "fontBounding";
}(MeasureModeEnum || (MeasureModeEnum = {}));
var STATUS$1;
!function (STATUS) {
STATUS[STATUS.INITIAL = 0] = "INITIAL", STATUS[STATUS.RUNNING = 1] = "RUNNING", STATUS[STATUS.PAUSE = 2] = "PAUSE";
}(STATUS$1 || (STATUS$1 = {}));
var AnimateStepType;
!function (AnimateStepType) {
AnimateStepType.wait = "wait", AnimateStepType.from = "from", AnimateStepType.to = "to", AnimateStepType.customAnimate = "customAnimate";
}(AnimateStepType || (AnimateStepType = {}));
var AnimateStatus;
!function (AnimateStatus) {
AnimateStatus[AnimateStatus.INITIAL = 0] = "INITIAL", AnimateStatus[AnimateStatus.RUNNING = 1] = "RUNNING", AnimateStatus[AnimateStatus.PAUSED = 2] = "PAUSED", AnimateStatus[AnimateStatus.END = 3] = "END";
}(AnimateStatus || (AnimateStatus = {}));
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
var eventemitter3 = {exports: {}};
(function (module) {
var has = Object.prototype.hasOwnProperty,
prefix = '~';
/**
* Constructor to create a storage for our `EE` objects.
* An `Events` instance is a plain object whose properties are event names.
*
* @constructor
* @private
*/
function Events() {}
//
// We try to not inherit from `Object.prototype`. In some engines creating an
// instance in this way is faster than calling `Object.create(null)` directly.
// If `Object.create(null)` is not supported we prefix the event names with a
// character to make sure that the built-in object properties are not
// overridden or used as an attack vector.
//
if (Object.create) {
Events.prototype = Object.create(null);
//
// This hack is needed because the `__proto__` property is still inherited in
// some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
//
if (!new Events().__proto__) prefix = false;
}
/**
* Representation of a single event listener.
*
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
* @constructor
* @private
*/
function EE(fn, context, once) {
this.fn = fn;
this.context = context;
this.once = once || false;
}
/**
* Add a listener for a given event.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} once Specify if the listener is a one-time listener.
* @returns {EventEmitter}
* @private
*/
function addListener(emitter, event, fn, context, once) {
if (typeof fn !== 'function') {
throw new TypeError('The listener must be a function');
}
var listener = new EE(fn, context || emitter, once),
evt = prefix ? prefix + event : event;
if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
return emitter;
}
/**
* Clear event by name.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} evt The Event name.
* @private
*/
function clearEvent(emitter, evt) {
if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
}
/**
* Minimal `EventEmitter` interface that is molded against the Node.js
* `EventEmitter` interface.
*
* @constructor
* @public
*/
function EventEmitter() {
this._events = new Events();
this._eventsCount = 0;
}
/**
* Return an array listing the events for which the emitter has registered
* listeners.
*
* @returns {Array}
* @public
*/
EventEmitter.prototype.eventNames = function eventNames() {
var names = [],
events,
name;
if (this._eventsCount === 0) return names;
for (name in events = this._events) {
if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
}
if (Object.getOwnPropertySymbols) {
return names.concat(Object.getOwnPropertySymbols(events));
}
return names;
};
/**
* Return the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Array} The registered listeners.
* @public
*/
EventEmitter.prototype.listeners = function listeners(event) {
var evt = prefix ? prefix + event : event,
handlers = this._events[evt];
if (!handlers) return [];
if (handlers.fn) return [handlers.fn];
for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
ee[i] = handlers[i].fn;
}
return ee;
};
/**
* Return the number of listeners listening to a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Number} The number of listeners.
* @public
*/
EventEmitter.prototype.listenerCount = function listenerCount(event) {
var evt = prefix ? prefix + event : event,
listeners = this._events[evt];
if (!listeners) return 0;
if (listeners.fn) return 1;
return listeners.length;
};
/**
* Calls each of the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Boolean} `true` if the event had listeners, else `false`.
* @public
*/
EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return false;
var listeners = this._events[evt],
len = arguments.length,
args,
i;
if (listeners.fn) {
if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
switch (len) {
case 1:
return listeners.fn.call(listeners.context), true;
case 2:
return listeners.fn.call(listeners.context, a1), true;
case 3:
return listeners.fn.call(listeners.context, a1, a2), true;
case 4:
return listeners.fn.call(listeners.context, a1, a2, a3), true;
case 5:
return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
case 6:
return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
}
for (i = 1, args = new Array(len - 1); i < len; i++) {
args[i - 1] = arguments[i];
}
listeners.fn.apply(listeners.context, args);
} else {
var length = listeners.length,
j;
for (i = 0; i < length; i++) {
if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
switch (len) {
case 1:
listeners[i].fn.call(listeners[i].context);
break;
case 2:
listeners[i].fn.call(listeners[i].context, a1);
break;
case 3:
listeners[i].fn.call(listeners[i].context, a1, a2);
break;
case 4:
listeners[i].fn.call(listeners[i].context, a1, a2, a3);
break;
default:
if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
args[j - 1] = arguments[j];
}
listeners[i].fn.apply(listeners[i].context, args);
}
}
}
return true;
};
/**
* Add a listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.on = function on(event, fn, context) {
return addListener(this, event, fn, context, false);
};
/**
* Add a one-time listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.once = function once(event, fn, context) {
return addListener(this, event, fn, context, true);
};
/**
* Re