Replace some ko.exportSymbol('*') in favour of ko['*']

and drop ko.exportProperty()

vendors/knockout/src/subscribables/dependentObservable.js

@@ -86,8 +86,8 @@ ko.computed = (evaluatorFunctionOrOptions, options) => {
     // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
     // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
     if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
-        ko.utils.domNodeDisposal.addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = () => {
-            computedObservable.dispose();
+        ko.utils.domNodeDisposal['addDisposeCallback'](state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = () => {
+            computedObservable['dispose']();
         });
     }
 
@@ -96,7 +96,7 @@ ko.computed = (evaluatorFunctionOrOptions, options) => {
 
 // Utility function that disposes a given dependencyTracking entry
 function computedDisposeDependencyCallback(id, entryToDispose) {
-    entryToDispose?.dispose?.();
+    entryToDispose?.['dispose']?.();
 }
 
 // This function gets called each time a dependency is detected while evaluating a computed.
@@ -237,7 +237,7 @@ var computedFn = {
         if (state.disposeWhenNodeIsRemoved && !ko.utils.domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen?.()) {
             // See comment above about suppressDisposalUntilDisposeWhenReturnsFalse
             if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
-                computedObservable.dispose();
+                computedObservable['dispose']();
                 return;
             }
         } else {
@@ -285,7 +285,7 @@ var computedFn = {
         var newValue = evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
 
         if (!state.dependenciesCount) {
-            computedObservable.dispose();
+            computedObservable['dispose']();
             changed = true; // When evaluation causes a disposal, make sure all dependent computeds get notified so they'll see the new state
         } else {
             changed = computedObservable.isDifferent(state.latestValue, newValue);
@@ -353,11 +353,11 @@ var computedFn = {
             self._limitChange(self, !isChange /* isDirty */);
         };
     },
-    dispose() {
+    'dispose'() {
         var state = this[computedState];
         if (!state.isSleeping && state.dependencyTracking) {
             ko.utils.objectForEach(state.dependencyTracking, (id, dependency) =>
-                dependency.dispose?.()
+                dependency['dispose']?.()
             );
         }
         if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {
@@ -419,13 +419,13 @@ var pureComputedOverrides = {
         var state = this[computedState];
         if (!state.isDisposed && event == 'change' && !this.hasSubscriptionsForEvent('change')) {
             ko.utils.objectForEach(state.dependencyTracking, (id, dependency) => {
-                if (dependency.dispose) {
+                if (dependency['dispose']) {
                     state.dependencyTracking[id] = {
                         _target: dependency._target,
                         _order: dependency._order,
                         _version: dependency._version
                     };
-                    dependency.dispose();
+                    dependency['dispose']();
                 }
             });
             state.isSleeping = true;
@@ -451,11 +451,10 @@ Object.setPrototypeOf(computedFn, ko.subscribable['fn']);
 // Set the proto values for ko.computed
 var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
 computedFn[protoProp] = ko.computed;
+ko.computed['fn'] = computedFn;
 
 ko.exportSymbol('computed', ko.computed);
-ko.exportSymbol('isComputed', instance => (typeof instance == 'function' && instance[protoProp] === computedFn[protoProp]));
-ko.exportSymbol('computed.fn', computedFn);
-ko.exportProperty(computedFn, 'dispose', computedFn.dispose);
+ko['isComputed'] = instance => (typeof instance == 'function' && instance[protoProp] === computedFn[protoProp]);
 
 ko.pureComputed = (evaluatorFunctionOrOptions) => {
     if (typeof evaluatorFunctionOrOptions === 'function') {

vendors/knockout/src/subscribables/extenders.js

@@ -1,4 +1,4 @@
-ko.extenders = {
+ko['extenders'] = {
     'debounce': (target, timeout) => target.limit(callback => debounce(callback, timeout)),
 
     'rateLimit': (target, timeout) => target.limit(callback => throttle(callback, timeout)),
@@ -34,5 +34,3 @@ function debounce(callback, timeout) {
         timeoutInstance = setTimeout(callback, timeout);
     };
 }
-
-ko.exportSymbol('extenders', ko.extenders);

vendors/knockout/src/subscribables/observableArray.changeTracking.js

@@ -1,5 +1,5 @@
 const arrayChangeEventName = 'arrayChange';
-ko.extenders['trackArrayChanges'] = (target, options) => {
+ko['extenders']['trackArrayChanges'] = (target, options) => {
     // Use the provided options--each call to trackArrayChanges overwrites the previously set options
     target.compareArrayOptions = {};
     if (typeof options == "object") {
@@ -31,8 +31,8 @@ ko.extenders['trackArrayChanges'] = (target, options) => {
     target.afterSubscriptionRemove = event => {
         underlyingAfterSubscriptionRemoveFunction?.call(target, event);
         if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
-            changeSubscription?.dispose();
-            spectateSubscription?.dispose();
+            changeSubscription?.['dispose']();
+            spectateSubscription?.['dispose']();
             spectateSubscription = changeSubscription = null;
             trackingChanges = false;
             previousContents = undefined;

vendors/knockout/src/subscribables/observableArray.js

@@ -1,17 +1,17 @@
-ko.observableArray = initialValues => {
+ko['observableArray'] = initialValues => {
     initialValues = initialValues || [];
 
     if (typeof initialValues != 'object' || !('length' in initialValues))
         throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
 
-    return Object.setPrototypeOf(ko.observable(initialValues), ko.observableArray['fn']).extend({'trackArrayChanges':true});
+    return Object.setPrototypeOf(ko.observable(initialValues), ko['observableArray']['fn']).extend({'trackArrayChanges':true});
 };
 
 const IS_OBSERVABLE_ARRAY = Symbol('IS_OBSERVABLE_ARRAY');
 
 // Note that for browsers that don't support proto assignment, the
 // inheritance chain is created manually in the ko.observableArray constructor
-ko.observableArray['fn'] = Object.setPrototypeOf({
+ko['observableArray']['fn'] = Object.setPrototypeOf({
     [IS_OBSERVABLE_ARRAY]: 1,
     'remove'(valueOrPredicate) {
         var underlyingArray = this.peek();
@@ -43,7 +43,7 @@ Object.getOwnPropertyNames(Array.prototype).forEach(methodName => {
             // https://developer.mozilla.org/tr/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype#mutator_methods
             // Important: Do not add any additional functions here that may reasonably be used to *read* data from the array
             // because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale
-            ko.observableArray['fn'][methodName] = function (...args) {
+            ko['observableArray']['fn'][methodName] = function (...args) {
                 // Use "peek" to avoid creating a subscription in any computed that we're executing in the context of
                 // (for consistency with mutating regular observables)
                 var underlyingArray = this.peek();
@@ -56,14 +56,11 @@ Object.getOwnPropertyNames(Array.prototype).forEach(methodName => {
             };
         } else {
             // Accessor and Iteration methods
-            ko.observableArray['fn'][methodName] = function (...args) {
+            ko['observableArray']['fn'][methodName] = function (...args) {
                 return this()[methodName](...args);
             };
         }
     }
 });
 
-ko.isObservableArray = obj => !!(obj && obj[IS_OBSERVABLE_ARRAY]);
-
-ko.exportSymbol('observableArray', ko.observableArray);
-ko.exportSymbol('isObservableArray', ko.isObservableArray);
+ko['isObservableArray'] = obj => !!(obj && obj[IS_OBSERVABLE_ARRAY]);

vendors/knockout/src/subscribables/subscribable.js

@@ -8,10 +8,9 @@ class koSubscription
         this._isDisposed = false;
         this._node = null;
         this._domNodeDisposalCallback = null;
-        ko.exportProperty(this, 'dispose', this.dispose);
     }
 
-    dispose() {
+    'dispose'() {
         var self = this;
         if (!self._isDisposed) {
             self._domNodeDisposalCallback
@@ -26,7 +25,7 @@ class koSubscription
     disposeWhenNodeIsRemoved(node) {
         // MutationObserver ?
         this._node = node;
-        ko.utils.domNodeDisposal.addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
+        ko.utils.domNodeDisposal['addDisposeCallback'](node, this._domNodeDisposalCallback = this['dispose'].bind(this));
     }
 }
 
@@ -174,7 +173,7 @@ var ko_subscribable_fn = {
         var target = this;
         if (requestedExtenders) {
             ko.utils.objectForEach(requestedExtenders, (key, value) => {
-                var extenderHandler = ko.extenders[key];
+                var extenderHandler = ko['extenders'][key];
                 if (typeof extenderHandler == 'function') {
                     target = extenderHandler(target, value) || target;
                 }